Feature #14473 » v5-0001-range.c-allow-cover-to-accept-Range-argument.patch
| range.c | ||
|---|---|---|
|
return Qundef;
|
||
|
}
|
||
|
static int r_cover_range_p(VALUE range, VALUE beg, VALUE end, VALUE val);
|
||
|
/*
|
||
|
* call-seq:
|
||
|
* rng.cover?(obj) -> true or false
|
||
|
* rng.cover?(obj) -> true or false
|
||
|
* rng.cover?(range) -> true or false
|
||
|
*
|
||
|
* Returns <code>true</code> if +obj+ is between the begin and end of
|
||
|
* the range.
|
||
| ... | ... | |
|
* This tests <code>begin <= obj <= end</code> when #exclude_end? is +false+
|
||
|
* and <code>begin <= obj < end</code> when #exclude_end? is +true+.
|
||
|
*
|
||
|
* ("a".."z").cover?("c") #=> true
|
||
|
* ("a".."z").cover?("5") #=> false
|
||
|
* ("a".."z").cover?("cc") #=> true
|
||
|
* Returns <code>true</code> for a Range when it is covered by the receiver,
|
||
|
* by comparing the begin and end values directly. In the specific case of
|
||
|
* <code>(a..b).cover?(c...d)</code> with <code>a <= c && b < d</code> this is
|
||
|
* not possible, and <code>(c...d).max</code> must be calculated, which can
|
||
|
* raise or exhibit poor performance.
|
||
|
*
|
||
|
* ("a".."z").cover?("c") #=> true
|
||
|
* ("a".."z").cover?("5") #=> false
|
||
|
* ("a".."z").cover?("cc") #=> true
|
||
|
* (1..5).cover?(2..3) #=> true
|
||
|
* (1..5).cover?(0..6) #=> false
|
||
|
* (1..5).cover?(1...6) #=> true
|
||
|
*/
|
||
|
static VALUE
|
||
|
range_cover(VALUE range, VALUE val)
|
||
|
{
|
||
| ... | ... | |
|
beg = RANGE_BEG(range);
|
||
|
end = RANGE_END(range);
|
||
|
if (rb_obj_is_kind_of(val, rb_cRange)) {
|
||
|
return RBOOL(r_cover_range_p(range, beg, end, val));
|
||
|
}
|
||
|
return r_cover_p(range, beg, end, val);
|
||
|
}
|
||
|
static int
|
||
|
r_cover_range_p(VALUE range, VALUE beg, VALUE end, VALUE val)
|
||
|
{
|
||
|
VALUE val_beg, val_end;
|
||
|
int cmp_end;
|
||
|
val_beg = RANGE_BEG(val);
|
||
|
val_end = RANGE_END(val);
|
||
|
if (!r_cover_p(range, beg, end, val_beg)) return FALSE;
|
||
|
cmp_end = r_less(end, val_end);
|
||
|
if (EXCL(range) == EXCL(val)) {
|
||
|
return cmp_end >= 0;
|
||
|
} else if (EXCL(range)) {
|
||
|
return cmp_end > 0;
|
||
|
} else if (cmp_end >= 0) {
|
||
|
return TRUE;
|
||
|
}
|
||
|
return r_less(end, rb_funcallv(val, rb_intern("max"), 0, 0)) >= 0;
|
||
|
}
|
||
|
static VALUE
|
||
|
r_cover_p(VALUE range, VALUE beg, VALUE end, VALUE val)
|
||
|
{
|
||
| test/ruby/test_range.rb | ||
|---|---|---|
|
assert_not_operator(5..., :cover?, 0)
|
||
|
assert_not_operator(5..., :cover?, "a")
|
||
|
assert_operator(5.., :cover?, 10)
|
||
|
assert_operator(2..5, :cover?, 2..5)
|
||
|
assert_operator(2...6, :cover?, 2...6)
|
||
|
assert_operator(2...6, :cover?, 2..5)
|
||
|
assert_operator(2..5, :cover?, 2...6)
|
||
|
assert_operator(2..5, :cover?, 2..4)
|
||
|
assert_operator(2..5, :cover?, 2...4)
|
||
|
assert_operator(2..5, :cover?, 2...5)
|
||
|
assert_operator(2..5, :cover?, 3..5)
|
||
|
assert_operator(2..5, :cover?, 3..4)
|
||
|
assert_operator(2..5, :cover?, 3...6)
|
||
|
assert_operator(2...6, :cover?, 2...5)
|
||
|
assert_operator(2...6, :cover?, 2..5)
|
||
|
assert_operator(2..6, :cover?, 2...6)
|
||
|
assert_operator(2.., :cover?, 2..)
|
||
|
assert_operator(2.., :cover?, 3..)
|
||
|
assert_operator(2.0..5.0, :cover?, 2..3)
|
||
|
assert_operator(2..5, :cover?, 2.0..3.0)
|
||
|
assert_operator(2..5, :cover?, 2.0...3.0)
|
||
|
assert_operator(2..5, :cover?, 2.0...5.0)
|
||
|
assert_operator(2.0..5.0, :cover?, 2.0...3.0)
|
||
|
assert_operator('aa'..'zz', :cover?, 'aa'...'bb')
|
||
|
assert_not_operator(2..5, :cover?, 1..5)
|
||
|
assert_not_operator(2...6, :cover?, 1..5)
|
||
|
assert_not_operator(2..5, :cover?, 1...6)
|
||
|
assert_not_operator(1..3, :cover?, 1...6)
|
||
|
assert_not_operator(2..5, :cover?, 2..6)
|
||
|
assert_not_operator(2...6, :cover?, 2..6)
|
||
|
assert_not_operator(2...6, :cover?, 2...7)
|
||
|
assert_not_operator(2..3, :cover?, 1..4)
|
||
|
assert_not_operator(1..2, :cover?, 1.0..3.0)
|
||
|
assert_not_operator(1.0..2.9, :cover?, 1.0..3.0)
|
||
|
assert_not_operator(1..2, :cover?, 4..3)
|
||
|
assert_not_operator(2..1, :cover?, 1..2)
|
||
|
assert_not_operator(1...2, :cover?, 1...3)
|
||
|
assert_not_operator(2.., :cover?, 1..)
|
||
|
assert_not_operator('aa'..'zz', :cover?, 'aa'...'zzz')
|
||
|
assert_raise(TypeError) { (1..10).cover?(1...10.1) }
|
||
|
end
|
||
|
def test_beg_len
|
||