I didn't know this was available. I think we should and I've documented it.

However, I find myself in the weeds gem design wise.

I'd expect to be able to get back a body_part from `.where(type: 'text/plain')` on which I could call content.

```ruby
result = message.body_parts.where(type: 'text/plain')
result.content #=>  plain text content here
```

But that isn't the path to body content. 

```
[57] pry(main)> m.class
=> ContextIO::Message
[52] pry(main)> result = m.body_parts.where(type: 'text/plain')
=> #<ContextIO::BodyPartCollection:0x007f8d1b9d9248
[53] pry(main)> result.class
=> ContextIO::BodyPartCollection
[58] pry(main)> result.methods.grep(/content/)
=> []
[60] pry(main)> result.methods
=> [:resource_class,
 :message,
...
```

`body_parts.where(type: 'text/plain')` returns a `ContextIO::BodyPartCollection` which means you need take the first result from the collection, even though in this use case there will only ever be one, and only one, result:

```ruby
result = m.body_parts.where(type: 'text/plain').first
```

I've documented it this way, but is this intended behavior? Seems like if you wanted to highlight this method as a quick way to get at a single result, then it should return a single instance right away. 

However, I can also see that .where needs to always return a collection and departing from that convention is a mistake. 

I'd like to make my own gems one day and am interested to hear the right way to think through these types of decisions.