

What are your Ruby Regex Idioms? - rahulvohra
http://blog.samstokes.co.uk/post/251167556/regex-style-in-ruby

======
sant0sk1
I use Rubular all the time for testing my regexes with ease. Give it a shot,
its really well done:

<http://rubular.com/>

~~~
samstokes
Looks like a useful tool. I've been using a similar one:
<http://regex.powertoy.org/>

The latter supports several languages' regex dialects, and I like the visual
way it displays group matches, particularly when groups are nested. It can be
a bit clunky, though, whereas Rubular is pretty clean and usable.

------
nanijoe
This (ruby) regex thing still gives me a headache , esp when I'm trying to
figure out other people's code

~~~
carbon8
You can also use this as String#slice, which is a little clearer:

    
    
        "foo@example.com".slice(/@(.*)/, 1)

------
sofal
One of my favorite patterns:

    
    
      _, username, domain = */([^@]+)@(.+$)/.match("foo@example.com")

~~~
jherdman
If you're capturing something you don't want, you can always prefix your match
with '?:' to have a non-capturing group.

FWIW, I personally prefer the #match method. Some of the examples in this
article just make me want to hurt people. Especially usage of $1, $2, etc.

~~~
tierack
In that case, /([^@]+)@(.+$)/.match("foo@example.com")[0] returns the whole
string matched by the expression, and [1] and [2] return the first and second
groups. That's why the throwaway is there. To get rid of the throwaway, this
is a possibility:

    
    
      username, domain = */([^@]+)@(.+$)/.match("foo@example.com").captures
    

Of course, your string better match, otherwise you'll get a NoMethodError.

------
iamwil
I didn't see it mentioned, but, btw, this code allows a method to introspect
to figure out what the method name that's currently being executed.

caller[0][/`([^']*)'/, 1]

Note that you only need to do this for Ruby 1.8. In Ruby 1.9, there will be a
__method__() and __callee__() method that does the same thing.

------
zzleeper
Woah.. I want that for Python..

~~~
jacobolus
I sure don’t. Putting a regular expression in a slice for a string runs
totally counter to all existing python idioms, and would utterly confuse
anyone trying to read the code. There are _definitely_ other ways of
accomplishing this with reasonably compact syntax that are also intuitive and
clear. (But I'm unconvinced it needs special syntax at all. It saves a couple
lines here and there, maybe, but at the cost of making the language more
complex.)

    
    
      caller[0][/`([^']*)'/, 1]
    

isn't really _so_ much shorter than:

    
    
      re.search("`([^']*)'", caller[0]).group(1)
    

and the latter is quite a bit more explicit.

~~~
samstokes
> I'm unconvinced it needs special syntax at all.

What's interesting is that it's actually _not_ special syntax - at least, it's
not special syntax for regex usage. The syntax obj[arg, arg, arg] looks weird
because in most languages things that look like subscripts can't have multiple
arguments, but it's just sugar for the method call obj.[](arg, arg, arg),
which is pretty mundane. The semantics are just the semantics of that method
on the class of 'obj', and can therefore be defined in library or user code.

Note I'm not defending the specific use of it here to write odd-looking regex
code - I just think it's interesting that the language is flexible enough to
allow that kind of usage _without_ special-casing it.

Raganwald wrote a blog post [1] along similar lines, arguing that it's a core
part of Ruby's language philosophy, about this snippet:

    
    
        (1..100).inject(&:+)
    

[1]: <http://weblog.raganwald.com/2008/02/1100inject.html>

~~~
jacobolus
Fair enough. I don’t like the special semantics then, that say that string
objects take regular expressions as possible slice indices. It's trying to be
too cute, and compactness comes at the direct expense of clarity. Basically
the reason I don't like Ruby generally, is that everything tries to be too
clever by half, too many behaviors crammed into too few parts. It's sort of
halfway from Python to Perl.

~~~
carbon8
_"say that string objects take regular expressions as possible slice
indices."_

I think it would be more accurate to say that Ruby's String#[] aka
String#slice method accepts arguments other than just indices (including
regular expressions and other strings) for returning substrings/subpatterns.
It's just a different approach, intuitive and rather uncontroversial, IMO.

------
grandalf

      (foo){2,5}

