From cd10cfa6c1da6ed8e1baf5cdb814e159c1314b73 Mon Sep 17 00:00:00 2001 From: Owen Stephens Date: Thu, 2 Aug 2018 00:38:45 +0100 Subject: [PATCH v6] range.c: allow cover? to accept Range argument --- range.c | 59 ++++++++++++++++++++++++++++++++++++++--- test/ruby/test_range.rb | 46 ++++++++++++++++++++++++++++++++ 2 files changed, 101 insertions(+), 4 deletions(-) diff --git a/range.c b/range.c index bcc8d1a8f4..1ca5930f60 100644 --- a/range.c +++ b/range.c @@ -1326,10 +1326,12 @@ range_include_internal(VALUE range, VALUE val) 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 true if +obj+ is between the begin and end of * the range. @@ -1337,9 +1339,19 @@ range_include_internal(VALUE range, VALUE val) * This tests begin <= obj <= end when #exclude_end? is +false+ * and begin <= obj < end when #exclude_end? is +true+. * - * ("a".."z").cover?("c") #=> true - * ("a".."z").cover?("5") #=> false - * ("a".."z").cover?("cc") #=> true + * Returns true for a Range when it is covered by the receiver, + * by comparing the begin and end values directly. In the specific case of + * (a..b).cover?(c...d) with a <= c && b < d this is + * not possible, and (c...d).max must be calculated, which may + * exhibit poor performance if c is non-numeric. Returns false if + * the begin value of the Range is larger than the end value. + * + * ("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 @@ -1349,9 +1361,48 @@ 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 VALUE +r_call_max(VALUE r) +{ + return rb_funcallv(r, rb_intern("max"), 0, 0); +} + +static int +r_cover_range_p(VALUE range, VALUE beg, VALUE end, VALUE val) +{ + VALUE val_beg, val_end, val_max; + int cmp_end; + + val_beg = RANGE_BEG(val); + val_end = RANGE_END(val); + + if (!NIL_P(end) && NIL_P(val_end)) return FALSE; + if (!NIL_P(val_end) && r_less(val_beg, val_end) > -EXCL(val)) return FALSE; + 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; + } + + val_max = rb_rescue2(r_call_max, val, NULL, Qnil, rb_eTypeError, (VALUE)0); + if (val_max == Qnil) return FALSE; + + return r_less(end, val_max) >= 0; +} + static VALUE r_cover_p(VALUE range, VALUE beg, VALUE end, VALUE val) { diff --git a/test/ruby/test_range.rb b/test/ruby/test_range.rb index eada19cfb6..2e9055f012 100644 --- a/test/ruby/test_range.rb +++ b/test/ruby/test_range.rb @@ -521,6 +521,52 @@ def test_cover 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(1.., :cover?, 1..10) + 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(2.0..5.0, :cover?, 2.0...5.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(2.., :cover?, 1..10) + assert_not_operator(1..10, :cover?, 1..) + assert_not_operator(1..5, :cover?, 3..2) + assert_not_operator(1..10, :cover?, 3...2) + assert_not_operator(1..10, :cover?, 3...3) + assert_not_operator('aa'..'zz', :cover?, 'aa'...'zzz') + assert_not_operator(1..10, :cover?, 1...10.1) end def test_beg_len -- 2.18.0