Ruby Regex: efficient way of capturing and deleting simultaneously - ruby

Question

I am deleting comments from a code file using regular expressions in ruby. The code is C++ (but i think this is not relevant) and the file contains something like:
/*
Hello! I'm a comment!
*/
int main(int argc, char* argv[])
{
Foo foo;
foo.bar();
return 0;
}
My goal is to remove the comments from the code and, at the same time, to parse them, which for now I can achieve by doing capture and then deleting:
text.scan(UGLY_COMMENTS_REGEX).each do |m|
m.method_for_printing_matched_comment
end
text = text.gsub(UGLY_COMMENTS_REGEX,'');
Another alternative that occurs to me is doing the gsub for each regex match instead of doing it with the full regex, something like:
text.scan(UGLY_COMMENTS_REGEX).each do |m|
m.method_for_printing_matched_comment
text = text.gsub(m,'');
end
The problem with this (also suboptimal) alternative is that it is not straightforward when the match contains "groups", e.g m[0], m[1]...
As doing this seems extremely inefficient I was wondering if there is any way of doing the match just once (for both capturing and deleting).

Answer 1

String#gsub! (and other String#gsub, String#sub!, String#sub) accepts an optional block (which will be called with a matched string). So you can do something like this:
text.gsub!(UGLY_COMMENTS_REGEX) { |m|
puts m # to print the matched comment / OR m.method_for_printing_matched_comment
'' # Return value is used as a replacement string; effectively remove the comment
}

Answer 2

I believe the following should work.
Code
def strip_comments(str)
comments = []
[str.split(/[ \t]*\/\*|\*\/(?:[ \t]*\n?/)
.select.with_index {|ar,i| i.even? ? true : (comments << ar.strip; false)}
.join,
comments]
end
Example
str =<<_
/*
Hello! I'm a comment!
*/
int main(int argc, char* argv[])
{
Foo foo;
/* Let's get this one too */
foo.bar();
return 0;
}
_
cleaned_code, comments = strip_comments(str)
puts cleaned_code
# int main(int argc, char* argv[])
# {
# Foo foo;
# foo.bar();
# return 0;
# }
puts comments
# Hello! I'm a comment!
# Let's get this one too
Explanation
For the example above.
comments = []
Splitting the string on /* or */ will create an array in which every other element is the text of a comment. The first element of the array will be text to retain, which will equal "" if the string begins with a comment. To retain correct formatting (I hope), I'm also stripping any spaces or tabs (but not newlines) that precede /* and any tabs or spaces followed by a newline, following */.
b = str.split(/[ \t]*\/\*|\*\/(?:[ \t]*\n)?/)
#=> ["",
# "\n Hello! I'm a comment!\n",
# "\nint main(int argc, char* argv[])\n{\n Foo foo;\n",
# " Let's get this one too ",
# " foo.bar();\n return 0;\n}\n"]
We wish to select the elements that are not comments, and at the same time keep the latter:
enum0 = b.select
#=> #<Enumerator: [
# "",
# "\n Hello! I'm a comment!\n",
# "\nint main(int argc, char* argv[])\n{\n Foo foo;\n",
# " Let's get this one too ",
# " foo.bar();\n return 0;\n}\n"]:select>
Add the index so we'll be able to figure out which elements are comments:
enum1 = enum0.with_index
#=> #<Enumerator: #<Enumerator: [
# "",
# "\n Hello! I'm a comment!\n",
# "\nint main(int argc, char* argv[])\n{\n Foo foo;\n",
# " Let's get this one too ",
# " foo.bar();\n return 0;\n}\n"]:select>:with_index>
You might think of enum1 as a "compound enumerator". To see what elements it will pass into its block, convert it to an array:
enum1.to_a
#=> [["", 0],
# ["\n Hello! I'm a comment!\n", 1],
# ["\nint main(int argc, char* argv[])\n{\n Foo foo;\n", 2],
# [" Let's get this one too ", 3],
# [" foo.bar();\n return 0;\n}\n", 4]]
Execute the enumerator with its block using Array#each:
c = enum1.each {|ar,i| i.even? ? true : (comments << ar.strip; false)}
#=> ["",
# "\nint main(int argc, char* argv[])\n{\n Foo foo;\n",
# " foo.bar();\n return 0;\n}\n"]
Confirm comments was constructed correctly:
puts comments
# Hello! I'm a comment!
# Let's get this one too
Join the elements of c:
cleaned_text = c.join
#=> "\nint main(int argc, char* argv[])\n{\n Foo foo;\n foo.bar();\n return 0;\n}\n"
and return:
[cleaned_text, comments]
as shown above.
Edit: a little better, I think:
def strip_comments(str)
a = str.split(/[ \t]*\/\*|\*\/(?:[ \t]*\n)?/)
a << "" if a.size.odd?
cleaned, comments = a.each_pair.transpose
[cleaned.join, comments.map(&:strip)]
end