Hello, I have a given piece of multiline HTML (which is generated using pandoc btw.) and I am trying to wrap certain elements (tags with a given class) with a <div>. I already took a look at the Text.Regex.PCRE module which seemed a reasonable choice because I am already familiar with similar regex implementations in other languages. I came up with the following function which takes a regex and replaces all matches within the given string using the provided function (which I would use to wrap the element) import Text.Regex.PCRE ((=~~)) -- Replaces the whole match for the given regex using the given function regexReplace :: String -> (String -> String) -> String -> String regexReplace regex replace text = go text where go text = case text =~~ regex of Just (before, match, after) -> before ++ replace match ++ go after _ -> text The problem with this function is, that it will not work on multiline strings. I would like to call it like this: newBody = regexReplace "<table class=\"sourceCode\".*?table>" wrap body wrap x = "<div class=\"sourceCodeWrap\">" ++ x ++ "</div>" Is there any way to easily pass some kind of multiline modifier to the regex in question? Or is this approach completely off and would something else be more appropriate/haskelly for the problem at hand? Thank you very much in advance.
I'd be more inclined to look at a solution involving manipulating the HTML structure, rather than trying a regexp-based approach, which will probably end up disappointing. (See this: http://stackoverflow.com/a/1732454/499609) I hope another Haskeller can speak to a library that would be good for this kind of purpose. To suit what you're doing now, though; if you change .*? to [\s\S]*?, it should work on multiline strings. If you can work out how to pass the 's' modifier to Text.Regexp.PCRE, that should also do it. —Arlen On Wednesday, 6 June 2012 at 3:05 PM, Rico Moorman wrote:
Hello,
I have a given piece of multiline HTML (which is generated using pandoc btw.) and I am trying to wrap certain elements (tags with a given class) with a <div>.
I already took a look at the Text.Regex.PCRE module which seemed a reasonable choice because I am already familiar with similar regex implementations in other languages.
I came up with the following function which takes a regex and replaces all matches within the given string using the provided function (which I would use to wrap the element)
import Text.Regex.PCRE ((=~~))
-- Replaces the whole match for the given regex using the given function regexReplace :: String -> (String -> String) -> String -> String regexReplace regex replace text = go text where go text = case text =~~ regex of Just (before, match, after) -> before ++ replace match ++ go after _ -> text
The problem with this function is, that it will not work on multiline strings. I would like to call it like this:
newBody = regexReplace "<table class=\"sourceCode\".*?table>" wrap body wrap x = "<div class=\"sourceCodeWrap\">" ++ x ++ "</div>"
Is there any way to easily pass some kind of multiline modifier to the regex in question?
Or is this approach completely off and would something else be more appropriate/haskelly for the problem at hand?
Thank you very much in advance. _______________________________________________ Beginners mailing list Beginners@haskell.org (mailto:Beginners@haskell.org) http://www.haskell.org/mailman/listinfo/beginners
Thank you very much for this suggestion. I just tried the character class you mentioned and it works. The stackoverflow post you mentioned was a nice read and I surely agree that regular expressions are normally not the way to go for most HTML munging needs. But luckily the generated HTML from pandoc is very specific and the <table> tag I wanted to match (for line-numbered code listings) does not contain any further tables so I thought it should be safe to approach it like this. The resulting code is now: -- Wraps numbered code listings within the page body with a div -- in order to be able to apply some more specific styling. wrapNumberedCodelistings (Page meta body) = Page meta newBody where newBody = regexReplace "<table\\s+class=\"sourceCode[^>]+>[\\s\\S]*?</table>" wrap body wrap x = "<div class=\"sourceCodeWrap\">" ++ x ++ "</div>" -- Replaces the whole match for the given regex using the given function regexReplace :: String -> (String -> String) -> String -> String regexReplace regex replace text = go text where go text = case text =~~ regex of Just (before, match, after) -> before ++ replace match ++ go after _ -> text Don't know though if it could be cleaned up further or even if this is by any means good style (being still fairly new to haskell). Furthermore I would still be very interested in the right approach to manipulating the HTML structure as a whole and I too hope that another Haskeller could name a more suitable solution for manipulating HTML. Or even how to pass the 's' modifier to Text.Regex.PCRE. Best regards, rico On Wed, Jun 6, 2012 at 7:11 AM, Arlen Cuss <a@unnali.com> wrote:
I'd be more inclined to look at a solution involving manipulating the HTML structure, rather than trying a regexp-based approach, which will probably end up disappointing. (See this: http://stackoverflow.com/a/1732454/499609 )
I hope another Haskeller can speak to a library that would be good for this kind of purpose.
To suit what you're doing now, though; if you change .*? to [\s\S]*?, it should work on multiline strings. If you can work out how to pass the 's' modifier to Text.Regexp.PCRE, that should also do it.
—Arlen
On Wednesday, 6 June 2012 at 3:05 PM, Rico Moorman wrote:
Hello,
I have a given piece of multiline HTML (which is generated using pandoc btw.) and I am trying to wrap certain elements (tags with a given class) with a <div>.
I already took a look at the Text.Regex.PCRE module which seemed a reasonable choice because I am already familiar with similar regex implementations in other languages.
I came up with the following function which takes a regex and replaces all matches within the given string using the provided function (which I would use to wrap the element)
import Text.Regex.PCRE ((=~~))
-- Replaces the whole match for the given regex using the given function regexReplace :: String -> (String -> String) -> String -> String regexReplace regex replace text = go text where go text = case text =~~ regex of Just (before, match, after) -> before ++ replace match ++ go after _ -> text
The problem with this function is, that it will not work on multiline strings. I would like to call it like this:
newBody = regexReplace "<table class=\"sourceCode\".*?table>" wrap body wrap x = "<div class=\"sourceCodeWrap\">" ++ x ++ "</div>"
Is there any way to easily pass some kind of multiline modifier to the regex in question?
Or is this approach completely off and would something else be more appropriate/haskelly for the problem at hand?
Thank you very much in advance. _______________________________________________ Beginners mailing list Beginners@haskell.org (mailto:Beginners@haskell.org) http://www.haskell.org/mailman/listinfo/beginners
Exploring the documentation for Text.Regex.PCRE, I've found "CompOption": http://hackage.haskell.org/packages/archive/regex-pcre/0.94.4/doc/html/Text-... The constants are listed below; the one you want is probably compDotAll, to make "." match newlines as well. I'm not 100% sure if this is the module you want, though, and I can't seem to get regex-pcre installed, so I can't test. Apologies! On Wednesday, 6 June 2012 at 4:52 PM, Rico Moorman wrote:
Thank you very much for this suggestion. I just tried the character class you mentioned and it works.
The stackoverflow post you mentioned was a nice read and I surely agree that regular expressions are normally not the way to go for most HTML munging needs. But luckily the generated HTML from pandoc is very specific and the <table> tag I wanted to match (for line-numbered code listings) does not contain any further tables so I thought it should be safe to approach it like this.
The resulting code is now:
-- Wraps numbered code listings within the page body with a div -- in order to be able to apply some more specific styling. wrapNumberedCodelistings (Page meta body) = Page meta newBody where newBody = regexReplace "<table\\s+class=\"sourceCode[^>]+>[\\s\\S]*?</table>" wrap body wrap x = "<div class=\"sourceCodeWrap\">" ++ x ++ "</div>"
-- Replaces the whole match for the given regex using the given function regexReplace :: String -> (String -> String) -> String -> String regexReplace regex replace text = go text where go text = case text =~~ regex of Just (before, match, after) -> before ++ replace match ++ go after _ -> text
Don't know though if it could be cleaned up further or even if this is by any means good style (being still fairly new to haskell).
Furthermore I would still be very interested in the right approach to manipulating the HTML structure as a whole and I too hope that another Haskeller could name a more suitable solution for manipulating HTML. Or even how to pass the 's' modifier to Text.Regex.PCRE.
Best regards,
rico
On Wed, Jun 6, 2012 at 7:11 AM, Arlen Cuss <a@unnali.com (mailto:a@unnali.com)> wrote:
I'd be more inclined to look at a solution involving manipulating the HTML structure, rather than trying a regexp-based approach, which will probably end up disappointing. (See this: http://stackoverflow.com/a/1732454/499609)
I hope another Haskeller can speak to a library that would be good for this kind of purpose.
To suit what you're doing now, though; if you change .*? to [\s\S]*?, it should work on multiline strings. If you can work out how to pass the 's' modifier to Text.Regexp.PCRE, that should also do it.
—Arlen
On Wednesday, 6 June 2012 at 3:05 PM, Rico Moorman wrote:
Hello,
I have a given piece of multiline HTML (which is generated using pandoc btw.) and I am trying to wrap certain elements (tags with a given class) with a <div>.
I already took a look at the Text.Regex.PCRE module which seemed a reasonable choice because I am already familiar with similar regex implementations in other languages.
I came up with the following function which takes a regex and replaces all matches within the given string using the provided function (which I would use to wrap the element)
import Text.Regex.PCRE ((=~~))
-- Replaces the whole match for the given regex using the given function regexReplace :: String -> (String -> String) -> String -> String regexReplace regex replace text = go text where go text = case text =~~ regex of Just (before, match, after) -> before ++ replace match ++ go after _ -> text
The problem with this function is, that it will not work on multiline strings. I would like to call it like this:
newBody = regexReplace "<table class=\"sourceCode\".*?table>" wrap body wrap x = "<div class=\"sourceCodeWrap\">" ++ x ++ "</div>"
Is there any way to easily pass some kind of multiline modifier to the regex in question?
Or is this approach completely off and would something else be more appropriate/haskelly for the problem at hand?
Thank you very much in advance. _______________________________________________ Beginners mailing list Beginners@haskell.org (mailto:Beginners@haskell.org) (mailto:Beginners@haskell.org) http://www.haskell.org/mailman/listinfo/beginners
Thank you again! Looking at the docs it seems that this could do the trick. A pity that you cannot install the package. Now I am wondering how I would integrate this in the replacement function or how to rewrite it properly. Looking at the type signature of =~~ (with my limited knowledge) it seems that I would have to "use" RegexMaker adding up the CompOptions needed? (=~~) :: (RegexMaker Regex CompOption ExecOption source, RegexContext Regex source1 target, Monad m) => source1 -> source -> m target On Wed, Jun 6, 2012 at 9:46 AM, Arlen Cuss <a@unnali.com> wrote:
Exploring the documentation for Text.Regex.PCRE, I've found "CompOption":
http://hackage.haskell.org/packages/archive/regex-pcre/0.94.4/doc/html/Text-...
The constants are listed below; the one you want is probably compDotAll, to make "." match newlines as well. I'm not 100% sure if this is the module you want, though, and I can't seem to get regex-pcre installed, so I can't test. Apologies!
On Wednesday, 6 June 2012 at 4:52 PM, Rico Moorman wrote:
Thank you very much for this suggestion. I just tried the character class you mentioned and it works.
The stackoverflow post you mentioned was a nice read and I surely agree that regular expressions are normally not the way to go for most HTML munging needs. But luckily the generated HTML from pandoc is very specific and the <table> tag I wanted to match (for line-numbered code listings) does not contain any further tables so I thought it should be safe to approach it like this.
The resulting code is now:
-- Wraps numbered code listings within the page body with a div -- in order to be able to apply some more specific styling. wrapNumberedCodelistings (Page meta body) = Page meta newBody where newBody = regexReplace "<table\\s+class=\"sourceCode[^>]+>[\\s\\S]*?</table>" wrap body wrap x = "<div class=\"sourceCodeWrap\">" ++ x ++ "</div>"
-- Replaces the whole match for the given regex using the given function regexReplace :: String -> (String -> String) -> String -> String regexReplace regex replace text = go text where go text = case text =~~ regex of Just (before, match, after) -> before ++ replace match ++ go after _ -> text
Don't know though if it could be cleaned up further or even if this is by any means good style (being still fairly new to haskell).
Furthermore I would still be very interested in the right approach to manipulating the HTML structure as a whole and I too hope that another Haskeller could name a more suitable solution for manipulating HTML. Or even how to pass the 's' modifier to Text.Regex.PCRE.
Best regards,
rico
On Wed, Jun 6, 2012 at 7:11 AM, Arlen Cuss <a@unnali.com (mailto:a@unnali.com)> wrote:
I'd be more inclined to look at a solution involving manipulating the HTML structure, rather than trying a regexp-based approach, which will probably end up disappointing. (See this: http://stackoverflow.com/a/1732454/499609)
I hope another Haskeller can speak to a library that would be good for this kind of purpose.
To suit what you're doing now, though; if you change .*? to [\s\S]*?, it should work on multiline strings. If you can work out how to pass the 's' modifier to Text.Regexp.PCRE, that should also do it.
—Arlen
On Wednesday, 6 June 2012 at 3:05 PM, Rico Moorman wrote:
Hello,
I have a given piece of multiline HTML (which is generated using pandoc btw.) and I am trying to wrap certain elements (tags with a given class) with a <div>.
I already took a look at the Text.Regex.PCRE module which seemed a reasonable choice because I am already familiar with similar regex implementations in other languages.
I came up with the following function which takes a regex and replaces all matches within the given string using the provided function (which I would use to wrap the element)
import Text.Regex.PCRE ((=~~))
-- Replaces the whole match for the given regex using the given function regexReplace :: String -> (String -> String) -> String -> String regexReplace regex replace text = go text where go text = case text =~~ regex of Just (before, match, after) -> before ++ replace match ++ go after _ -> text
The problem with this function is, that it will not work on multiline strings. I would like to call it like this:
newBody = regexReplace "<table class=\"sourceCode\".*?table>" wrap body wrap x = "<div class=\"sourceCodeWrap\">" ++ x ++ "</div>"
Is there any way to easily pass some kind of multiline modifier to the regex in question?
Or is this approach completely off and would something else be more appropriate/haskelly for the problem at hand?
Thank you very much in advance. _______________________________________________ Beginners mailing list Beginners@haskell.org (mailto:Beginners@haskell.org) (mailto:Beginners@haskell.org) http://www.haskell.org/mailman/listinfo/beginners
Since I can't seem to get the PCRE package installed (not sure what's going on here: http://hpaste.org/69589), I gave it a go with plain Text.Regex, which should (?) use Text.Regex.Posix by default. λ> let regex = mkRegexWithOpts "abc(.*)def" False False in matchRegex regex "abc content\nmore def" Just [" content\nmore "] λ> See: http://hackage.haskell.org/packages/archive/regex-compat/0.92/doc/html/Text-... That said, Text.Regex.Posix is a bit broken, and you might want to use regex-tdfa. See also: * http://www.haskell.org/haskellwiki/Regex_Posix * http://www.haskell.org/haskellwiki/Regular_expressions Cheers, A On Wednesday, 6 June 2012 at 6:39 PM, Rico Moorman wrote:
Thank you again!
Looking at the docs it seems that this could do the trick. A pity that you cannot install the package.
Now I am wondering how I would integrate this in the replacement function or how to rewrite it properly.
Looking at the type signature of =~~ (with my limited knowledge) it seems that I would have to "use" RegexMaker adding up the CompOptions needed?
(=~~) :: (RegexMaker Regex CompOption ExecOption source, RegexContext Regex source1 target, Monad m) => source1 -> source -> m target
On Wed, Jun 6, 2012 at 9:46 AM, Arlen Cuss <a@unnali.com (mailto:a@unnali.com)> wrote:
Exploring the documentation for Text.Regex.PCRE, I've found "CompOption":
http://hackage.haskell.org/packages/archive/regex-pcre/0.94.4/doc/html/Text-...
The constants are listed below; the one you want is probably compDotAll, to make "." match newlines as well. I'm not 100% sure if this is the module you want, though, and I can't seem to get regex-pcre installed, so I can't test. Apologies!
On Wednesday, 6 June 2012 at 4:52 PM, Rico Moorman wrote:
Thank you very much for this suggestion. I just tried the character class you mentioned and it works.
The stackoverflow post you mentioned was a nice read and I surely agree that regular expressions are normally not the way to go for most HTML munging needs. But luckily the generated HTML from pandoc is very specific and the <table> tag I wanted to match (for line-numbered code listings) does not contain any further tables so I thought it should be safe to approach it like this.
The resulting code is now:
-- Wraps numbered code listings within the page body with a div -- in order to be able to apply some more specific styling. wrapNumberedCodelistings (Page meta body) = Page meta newBody where newBody = regexReplace "<table\\s+class=\"sourceCode[^>]+>[\\s\\S]*?</table>" wrap body wrap x = "<div class=\"sourceCodeWrap\">" ++ x ++ "</div>"
-- Replaces the whole match for the given regex using the given function regexReplace :: String -> (String -> String) -> String -> String regexReplace regex replace text = go text where go text = case text =~~ regex of Just (before, match, after) -> before ++ replace match ++ go after _ -> text
Don't know though if it could be cleaned up further or even if this is by any means good style (being still fairly new to haskell).
Furthermore I would still be very interested in the right approach to manipulating the HTML structure as a whole and I too hope that another Haskeller could name a more suitable solution for manipulating HTML. Or even how to pass the 's' modifier to Text.Regex.PCRE.
Best regards,
rico
On Wed, Jun 6, 2012 at 7:11 AM, Arlen Cuss <a@unnali.com (mailto:a@unnali.com)> wrote:
I'd be more inclined to look at a solution involving manipulating the HTML structure, rather than trying a regexp-based approach, which will probably end up disappointing. (See this: http://stackoverflow.com/a/1732454/499609)
I hope another Haskeller can speak to a library that would be good for this kind of purpose.
To suit what you're doing now, though; if you change .*? to [\s\S]*?, it should work on multiline strings. If you can work out how to pass the 's' modifier to Text.Regexp.PCRE, that should also do it.
—Arlen
On Wednesday, 6 June 2012 at 3:05 PM, Rico Moorman wrote:
Hello,
I have a given piece of multiline HTML (which is generated using pandoc btw.) and I am trying to wrap certain elements (tags with a given class) with a <div>.
I already took a look at the Text.Regex.PCRE module which seemed a reasonable choice because I am already familiar with similar regex implementations in other languages.
I came up with the following function which takes a regex and replaces all matches within the given string using the provided function (which I would use to wrap the element)
import Text.Regex.PCRE ((=~~))
-- Replaces the whole match for the given regex using the given function regexReplace :: String -> (String -> String) -> String -> String regexReplace regex replace text = go text where go text = case text =~~ regex of Just (before, match, after) -> before ++ replace match ++ go after _ -> text
The problem with this function is, that it will not work on multiline strings. I would like to call it like this:
newBody = regexReplace "<table class=\"sourceCode\".*?table>" wrap body wrap x = "<div class=\"sourceCodeWrap\">" ++ x ++ "</div>"
Is there any way to easily pass some kind of multiline modifier to the regex in question?
Or is this approach completely off and would something else be more appropriate/haskelly for the problem at hand?
Thank you very much in advance. _______________________________________________ Beginners mailing list Beginners@haskell.org (mailto:Beginners@haskell.org) (mailto:Beginners@haskell.org) http://www.haskell.org/mailman/listinfo/beginners
On Wed, Jun 6, 2012 at 10:39 AM, Rico Moorman <rico.moorman@gmail.com> wrote:
Now I am wondering how I would integrate this in the replacement function or how to rewrite it properly.
Looking at the type signature of =~~ (with my limited knowledge) it seems that I would have to "use" RegexMaker adding up the CompOptions needed?
(=~~) :: (RegexMaker Regex CompOption ExecOption source, RegexContext Regex source1 target, Monad m) => source1 -> source -> m target
What's non-obvious and trip a lot of people when they try to use regexes in Haskell is that most regex libraries use the same interface, which is specified in the regex-base and consists of several typeclasses that offers a very high degree of flexibility. =~and =~~ are only the simplified front-ends to this and are pretty inadequate for advanced usages (for instance compile and use multiple time the same regex, you should really avoid =~ in this case, or additional regex compilation options). To see the basic interface, look at Text.Regex.Base.RegexLike : http://hackage.haskell.org/packages/archive/regex-base/latest/doc/html/Text-... . In particular, what you want to do should be done with makeRegexOpts and match (or matchM), note that the available compilation and execution options can vary depending on the regex library you use and for regex-pcre, they're documented there : http://hackage.haskell.org/packages/archive/regex-pcre/latest/doc/html/Text-... -- Jedaï
Thank you for this important detail. Following the advice in this thread I tried to rewrite the function in terms of the lower-level interface instead of using =~~ -- qualified import to avoid clashes in main program import qualified Text.Regex.PCRE as RE regexReplace' :: String -> (String -> String) -> String -> String regexReplace' regex replace text = go text where regex' :: RE.Regex regex' = RE.makeRegexOpts RE.defaultCompOpt RE.defaultExecOpt regex replace' :: RE.MatchText String -> String replace' = undefined go text = case RE.matchOnceText regex' text of Just (before, match, after) -> before ++ replace' match ++ go after _ -> text Did you mean something like this? (besides that the replace' function still has to be filled in) If this is correct ... I am still a little lost though. I cannot come up with a way of matching the actual String out of the MatchText returned by matchOnceText ... http://hackage.haskell.org/packages/archive/regex-base/latest/doc/html/Text-... If I should structure the entire function differently, I would be very grateful to receive some pointers how. Best regards, rico On Wed, Jun 6, 2012 at 7:50 PM, Chaddaï Fouché <chaddai.fouche@gmail.com> wrote:
On Wed, Jun 6, 2012 at 10:39 AM, Rico Moorman <rico.moorman@gmail.com> wrote:
Now I am wondering how I would integrate this in the replacement function or how to rewrite it properly.
Looking at the type signature of =~~ (with my limited knowledge) it seems that I would have to "use" RegexMaker adding up the CompOptions needed?
(=~~) :: (RegexMaker Regex CompOption ExecOption source, RegexContext Regex source1 target, Monad m) => source1 -> source -> m target
What's non-obvious and trip a lot of people when they try to use regexes in Haskell is that most regex libraries use the same interface, which is specified in the regex-base and consists of several typeclasses that offers a very high degree of flexibility. =~and =~~ are only the simplified front-ends to this and are pretty inadequate for advanced usages (for instance compile and use multiple time the same regex, you should really avoid =~ in this case, or additional regex compilation options). To see the basic interface, look at Text.Regex.Base.RegexLike : http://hackage.haskell.org/packages/archive/regex-base/latest/doc/html/Text-... . In particular, what you want to do should be done with makeRegexOpts and match (or matchM), note that the available compilation and execution options can vary depending on the regex library you use and for regex-pcre, they're documented there : http://hackage.haskell.org/packages/archive/regex-pcre/latest/doc/html/Text-...
-- Jedaï
On Wed, Jun 6, 2012 at 10:08 PM, Rico Moorman <rico.moorman@gmail.com> wrote:
If this is correct ... I am still a little lost though. I cannot come up with a way of matching the actual String out of the MatchText returned by matchOnceText ... http://hackage.haskell.org/packages/archive/regex-base/latest/doc/html/Text-...
MatchText is an array, which allows for captures in the regex, for instance, if matching "hello Abel ! And goodbye." with "hello (\w+) ([.!?])", MatchText would be : array (0,2) [(0,("hello Abel !",(0,12))), (1,("Abel",(6,4))), (2,("!",(11,1)))] So if you want the whole matched text, you would use :
fst (match ! 0)
Or you could just use matchM :
go text = case RE.matchM regex' text of Just (before, match, after) -> before ++ replace' match ++ go after _ -> text
and have match be a string, just like before (since you don't use all the power of MatchText anyway). -- Jedaï
What's non-obvious and trip a lot of people when they try to use regexes in Haskell is that most regex libraries use the same interface, which is specified in the regex-base and consists of several typeclasses that offers a very high degree of flexibility. =~and =~~ are only the simplified front-ends to this and are pretty inadequate for advanced usages (for instance compile and use multiple time the same regex, you should really avoid =~ in this case, or additional regex compilation options). To see the basic interface, look at Text.Regex.Base.RegexLike : http://hackage.haskell.org/packages/archive/regex-base/latest/doc/html/Text-... . In particular, what you want to do should be done with makeRegexOpts and match (or matchM), note that the available compilation and execution options can vary depending on the regex library you use and for regex-pcre, they're documented there : http://hackage.haskell.org/packages/archive/regex-pcre/latest/doc/html/Text-...
-- Jedaï
By the way, do you know other good resources on Regular expressions in Haskell and especially the multiple backends (tdfa, posix and pcre e.g.) in combination with the basic interface and how to use this all together? Some example code would be really useful. Furthermore the following page states that the Text.Regex.Base stuff is being exported again by the newer/other regex modules. http://hackage.haskell.org/packages/archive/regex-base/0.93.2/doc/html/Text-... Does this mean I should use the specific regex modules directly or should I import the base and then specific functionality from the engine modules? Thank you very much in advance, Best regards, Rico
participants (3)
-
Arlen Cuss -
Chaddaï Fouché -
Rico Moorman