github
/
ruby
зеркало из https://github.com/github/ruby.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

Make Range#step to consistently use + for iteration (#7444) 

Make Range#step to consistently use + for iteration [Feature #18368]

Previously, non-numerics expected step to be integer,
and iterated with begin#succ, skipping over step value
steps. Since this commit, numeric and non-numeric iteration
behaves the same way, by using + operator.
This commit is contained in:
Victor Shepelev 2024-08-18 13:15:18 +03:00 коммит произвёл GitHub
Родитель 4dbf386ca2
Коммит d450f9d6a2
Не найден ключ, соответствующий данной подписи
Идентификатор ключа GPG: B5690EEEBB952194
6 изменённых файлов: 662 добавлений и 351 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

8
NEWS.md
Просмотреть файл

@ -43,6 +43,13 @@ Note: We're only listing outstanding class updates.
* Range
* Range#size now raises TypeError if the range is not iterable. [[Misc #18984]]
* Range#step now consistently has a semantics of iterating by using `+` operator
for all types, not only numerics. [[Feature #18368]]
```ruby
(Time.utc(2022, 2, 24)..).step(24*60*60).take(3)
#=> [2022-02-24 00:00:00 UTC, 2022-02-25 00:00:00 UTC, 2022-02-26 00:00:00 UTC]
```
* RubyVM::AbstractSyntaxTree
@ -168,3 +175,4 @@ See GitHub releases like [GitHub Releases of Logger](https://github.com/ruby/log
[Feature #20443]: https://bugs.ruby-lang.org/issues/20443
[Feature #20497]: https://bugs.ruby-lang.org/issues/20497
[Feature #20624]: https://bugs.ruby-lang.org/issues/20624
[Feature #18368]: https://bugs.ruby-lang.org/issues/18368

309
range.c
Просмотреть файл

@ -29,7 +29,7 @@
#include "internal/range.h"
VALUE rb_cRange;
static ID id_beg, id_end, id_excl;
static ID id_beg, id_end, id_excl, id_plus;
#define id_cmp idCmp
#define id_succ idSucc
#define id_min idMin
@ -308,40 +308,6 @@ range_each_func(VALUE range, int (*func)(VALUE, VALUE), VALUE arg)
}
}
static bool
step_i_iter(VALUE arg)
{
VALUE *iter = (VALUE *)arg;
if (FIXNUM_P(iter[0])) {
iter[0] -= INT2FIX(1) & ~FIXNUM_FLAG;
}
else {
iter[0] = rb_funcall(iter[0], '-', 1, INT2FIX(1));
}
if (iter[0] != INT2FIX(0)) return false;
iter[0] = iter[1];
return true;
}
static int
sym_step_i(VALUE i, VALUE arg)
{
if (step_i_iter(arg)) {
rb_yield(rb_str_intern(i));
}
return 0;
}
static int
step_i(VALUE i, VALUE arg)
{
if (step_i_iter(arg)) {
rb_yield(i);
}
return 0;
}
static int
discrete_object_p(VALUE obj)
{
@ -400,72 +366,123 @@ range_step_size(VALUE range, VALUE args, VALUE eobj)
/*
* call-seq:
* step(n = 1) {|element| ... } -> self
* step(n = 1) -> enumerator
* step(s = 1) {|element| ... } -> self
* step(s = 1) -> enumerator/arithmetic_sequence
*
* Iterates over the elements of +self+.
* Iterates over the elements of range in steps of +s+. The iteration is performed
* by <tt>+</tt> operator:
*
* With a block given and no argument,
* calls the block each element of the range; returns +self+:
* (0..6).step(2) { puts _1 } #=> 1..5
* # Prints: 0, 2, 4, 6
*
* a = []
* (1..5).step {|element| a.push(element) } # => 1..5
* a # => [1, 2, 3, 4, 5]
* a = []
* ('a'..'e').step {|element| a.push(element) } # => "a".."e"
* a # => ["a", "b", "c", "d", "e"]
* # Iterate between two dates in step of 1 day (24 hours)
* (Time.utc(2022, 2, 24)..Time.utc(2022, 3, 1)).step(24*60*60) { puts _1 }
* # Prints:
* # 2022-02-24 00:00:00 UTC
* # 2022-02-25 00:00:00 UTC
* # 2022-02-26 00:00:00 UTC
* # 2022-02-27 00:00:00 UTC
* # 2022-02-28 00:00:00 UTC
* # 2022-03-01 00:00:00 UTC
*
* With a block given and a positive integer argument +n+ given,
* calls the block with element +0+, element +n+, element <tt>2n</tt>, and so on:
* If <tt> + step</tt> decreases the value, iteration is still performed when
* step +begin+ is higher than the +end+:
*
* a = []
* (1..5).step(2) {|element| a.push(element) } # => 1..5
* a # => [1, 3, 5]
* a = []
* ('a'..'e').step(2) {|element| a.push(element) } # => "a".."e"
* a # => ["a", "c", "e"]
* (0..6).step(-2) { puts _1 }
* # Prints nothing
*
* With no block given, returns an enumerator,
* which will be of class Enumerator::ArithmeticSequence if +self+ is numeric;
* otherwise of class Enumerator:
* (6..0).step(-2) { puts _1 }
* # Prints: 6, 4, 2, 0
*
* e = (1..5).step(2) # => ((1..5).step(2))
* e.class # => Enumerator::ArithmeticSequence
* ('a'..'e').step # => #<Enumerator: ...>
* (Time.utc(2022, 3, 1)..Time.utc(2022, 2, 24)).step(-24*60*60) { puts _1 }
* # Prints:
* # 2022-03-01 00:00:00 UTC
* # 2022-02-28 00:00:00 UTC
* # 2022-02-27 00:00:00 UTC
* # 2022-02-26 00:00:00 UTC
* # 2022-02-25 00:00:00 UTC
* # 2022-02-24 00:00:00 UTC
*
* When the block is not provided, and range boundaries and step are Numeric,
* the method returns Enumerator::ArithmeticSequence.
*
* (1..5).step(2) # => ((1..5).step(2))
* (1.0..).step(1.5) #=> ((1.0..).step(1.5))
* (..3r).step(1/3r) #=> ((..3/1).step((1/3)))
*
* Enumerator::ArithmeticSequence can be further used as a value object for iteration
* or slicing of collections (see Array#[]). There is a convenience method #% with
* behavior similar to +step+ to produce arithmetic sequences more expressively:
*
* # Same as (1..5).step(2)
* (1..5) % 2 # => ((1..5).%(2))
*
* In a generic case, when the block is not provided, Enumerator is returned:
*
* ('a'..).step('b') #=> #<Enumerator: "a"..:step("b")>
* ('a'..).step('b').take(3) #=> ["a", "ab", "abb"]
*
* If +s+ is not provided, it is considered +1+ for ranges with numeric +begin+:
*
* (1..5).step { p _1 }
* # Prints: 1, 2, 3, 4, 5
*
* For non-Numeric ranges, step absence is an error:
*
* ('a'..'z').step { p _1 }
* # raises: step is required for non-numeric ranges (ArgumentError)
*
* Related: Range#%.
*/
static VALUE
range_step(int argc, VALUE *argv, VALUE range)
{
VALUE b, e, step, tmp;
VALUE b, e, v, step;
int c, dir;
b = RANGE_BEG(range);
e = RANGE_END(range);
step = (!rb_check_arity(argc, 0, 1) ? INT2FIX(1) : argv[0]);
const VALUE b_num_p = rb_obj_is_kind_of(b, rb_cNumeric);
const VALUE e_num_p = rb_obj_is_kind_of(e, rb_cNumeric);
if (rb_check_arity(argc, 0, 1))
step = argv[0];
else {
if (b_num_p || (NIL_P(b) && e_num_p))
step = INT2FIX(1);
else
rb_raise(rb_eArgError, "step is required for non-numeric ranges");
}
const VALUE step_num_p = rb_obj_is_kind_of(step, rb_cNumeric);
if (step_num_p && b_num_p && rb_equal(step, INT2FIX(0))) {
rb_raise(rb_eArgError, "step can't be 0");
}
if (!rb_block_given_p()) {
if (!rb_obj_is_kind_of(step, rb_cNumeric)) {
step = rb_to_int(step);
}
if (rb_equal(step, INT2FIX(0))) {
rb_raise(rb_eArgError, "step can't be 0");
}
const VALUE b_num_p = rb_obj_is_kind_of(b, rb_cNumeric);
const VALUE e_num_p = rb_obj_is_kind_of(e, rb_cNumeric);
if ((b_num_p && (NIL_P(e) || e_num_p)) || (NIL_P(b) && e_num_p)) {
// This code is allowed to create even beginless ArithmeticSequence, which can be useful,
// e.g., for array slicing:
// ary[(..-1) % 3]
if (step_num_p && ((b_num_p && (NIL_P(e) || e_num_p)) || (NIL_P(b) && e_num_p))) {
return rb_arith_seq_new(range, ID2SYM(rb_frame_this_func()), argc, argv,
range_step_size, b, e, step, EXCL(range));
}
RETURN_SIZED_ENUMERATOR(range, argc, argv, range_step_size);
// ...but generic Enumerator from beginless range is useless and probably an error.
if (NIL_P(b)) {
rb_raise(rb_eArgError, "#step for non-numeric beginless ranges is meaningless");
}
RETURN_SIZED_ENUMERATOR(range, argc, argv, 0);
}
step = check_step_domain(step);
VALUE iter[2] = {INT2FIX(1), step};
if (NIL_P(b)) {
rb_raise(rb_eArgError, "#step iteration for beginless ranges is meaningless");
}
if (FIXNUM_P(b) && NIL_P(e) && FIXNUM_P(step)) {
/* perform summation of numbers in C until their reach Fixnum limit */
long i = FIX2LONG(b), unit = FIX2LONG(step);
do {
rb_yield(LONG2FIX(i));
@ -473,71 +490,77 @@ range_step(int argc, VALUE *argv, VALUE range)
} while (FIXABLE(i));
b = LONG2NUM(i);
/* then switch to Bignum API */
for (;; b = rb_big_plus(b, step))
rb_yield(b);
}
else if (FIXNUM_P(b) && FIXNUM_P(e) && FIXNUM_P(step)) { /* fixnums are special */
else if (FIXNUM_P(b) && FIXNUM_P(e) && FIXNUM_P(step)) {
/* fixnums are special: summation is performed in C for performance */
long end = FIX2LONG(e);
long i, unit = FIX2LONG(step);
if (!EXCL(range))
end += 1;
i = FIX2LONG(b);
while (i < end) {
rb_yield(LONG2NUM(i));
if (i + unit < i) break;
i += unit;
}
}
else if (SYMBOL_P(b) && (NIL_P(e) || SYMBOL_P(e))) { /* symbols are special */
b = rb_sym2str(b);
if (NIL_P(e)) {
rb_str_upto_endless_each(b, sym_step_i, (VALUE)iter);
}
else {
rb_str_upto_each(b, rb_sym2str(e), EXCL(range), sym_step_i, (VALUE)iter);
if (unit < 0) {
if (!EXCL(range))
end -= 1;
i = FIX2LONG(b);
while (i > end) {
rb_yield(LONG2NUM(i));
i += unit;
}
} else {
if (!EXCL(range))
end += 1;
i = FIX2LONG(b);
while (i < end) {
rb_yield(LONG2NUM(i));
i += unit;
}
}
}
else if (ruby_float_step(b, e, step, EXCL(range), TRUE)) {
else if (b_num_p && step_num_p && ruby_float_step(b, e, step, EXCL(range), TRUE)) {
/* done */
}
else if (rb_obj_is_kind_of(b, rb_cNumeric) ||
!NIL_P(rb_check_to_integer(b, "to_int")) ||
!NIL_P(rb_check_to_integer(e, "to_int"))) {
ID op = EXCL(range) ? '<' : idLE;
VALUE v = b;
int i = 0;
while (NIL_P(e) || RTEST(rb_funcall(v, op, 1, e))) {
rb_yield(v);
i++;
v = rb_funcall(b, '+', 1, rb_funcall(INT2NUM(i), '*', 1, step));
}
}
else {
tmp = rb_check_string_type(b);
v = b;
if (!NIL_P(e)) {
if (b_num_p && step_num_p && r_less(step, INT2FIX(0)) < 0) {
// iterate backwards, for consistency with ArithmeticSequence
if (EXCL(range)) {
for (; r_less(e, v) < 0; v = rb_funcall(v, id_plus, 1, step))
rb_yield(v);
}
else {
for (; (c = r_less(e, v)) <= 0; v = rb_funcall(v, id_plus, 1, step)) {
rb_yield(v);
if (!c) break;
}
}
if (!NIL_P(tmp)) {
b = tmp;
if (NIL_P(e)) {
rb_str_upto_endless_each(b, step_i, (VALUE)iter);
}
else {
rb_str_upto_each(b, e, EXCL(range), step_i, (VALUE)iter);
} else {
// Direction of the comparison. We use it as a comparison operator in cycle:
// if begin < end, the cycle performs while value < end (iterating forward)
// if begin > end, the cycle performs while value > end (iterating backward with
// a negative step)
dir = r_less(b, e);
// One preliminary addition to check the step moves iteration in the same direction as
// from begin to end; otherwise, the iteration should be empty.
if (r_less(b, rb_funcall(b, id_plus, 1, step)) == dir) {
if (EXCL(range)) {
for (; r_less(v, e) == dir; v = rb_funcall(v, id_plus, 1, step))
rb_yield(v);
}
else {
for (; (c = r_less(v, e)) == dir || c == 0; v = rb_funcall(v, id_plus, 1, step)) {
rb_yield(v);
if (!c) break;
}
}
}
}
}
else {
if (!discrete_object_p(b)) {
rb_raise(rb_eTypeError, "can't iterate from %s",
rb_obj_classname(b));
}
if (!NIL_P(e))
range_each_func(range, step_i, (VALUE)iter);
else
for (;; b = rb_funcallv(b, id_succ, 0, 0))
step_i(b, (VALUE)iter);
}
else
for (;; v = rb_funcall(v, id_plus, 1, step))
rb_yield(v);
}
return range;
}
@ -545,29 +568,24 @@ range_step(int argc, VALUE *argv, VALUE range)
/*
* call-seq:
* %(n) {|element| ... } -> self
* %(n) -> enumerator
* %(n) -> enumerator or arithmetic_sequence
*
* Iterates over the elements of +self+.
* Same as #step (but doesn't provide default value for +n+).
* The method is convenient for experssive producing of Enumerator::ArithmeticSequence.
*
* With a block given, calls the block with selected elements of the range;
* returns +self+:
* array = [0, 1, 2, 3, 4, 5, 6]
*
* a = []
* (1..5).%(2) {|element| a.push(element) } # => 1..5
* a # => [1, 3, 5]
* a = []
* ('a'..'e').%(2) {|element| a.push(element) } # => "a".."e"
* a # => ["a", "c", "e"]
* # slice each second element:
* seq = (0..) % 2 #=> ((0..).%(2))
* array[seq] #=> [0, 2, 4, 6]
* # or just
* array[(0..) % 2] #=> [0, 2, 4, 6]
*
* With no block given, returns an enumerator,
* which will be of class Enumerator::ArithmeticSequence if +self+ is numeric;
* otherwise of class Enumerator:
* Note that due to operator precedence in Ruby, parentheses are mandatory around range
* in this case:
*
* e = (1..5) % 2 # => ((1..5).%(2))
* e.class # => Enumerator::ArithmeticSequence
* ('a'..'e') % 2 # => #<Enumerator: ...>
*
* Related: Range#step.
* (0..7) % 2 #=> ((0..7).%(2)) -- as expected
* 0..7 % 2 #=> 0..1 -- parsed as 0..(7 % 2)
*/
static VALUE
range_percent_step(VALUE range, VALUE step)
@ -2641,6 +2659,7 @@ Init_Range(void)
id_beg = rb_intern_const("begin");
id_end = rb_intern_const("end");
id_excl = rb_intern_const("excl");
id_plus = rb_intern_const("+");
rb_cRange = rb_struct_define_without_accessor(
"Range", rb_cObject, range_alloc,

409
spec/ruby/core/range/step_spec.rb
Просмотреть файл

@ -10,44 +10,50 @@ describe "Range#step" do
r.step { }.should equal(r)
end
it "raises TypeError if step" do
obj = mock("mock")
-> { (1..10).step(obj) { } }.should raise_error(TypeError)
ruby_version_is ""..."3.4" do
it "calls #to_int to coerce step to an Integer" do
obj = mock("Range#step")
obj.should_receive(:to_int).and_return(1)
(1..2).step(obj) { |x| ScratchPad << x }
ScratchPad.recorded.should eql([1, 2])
end
it "raises a TypeError if step does not respond to #to_int" do
obj = mock("Range#step non-integer")
-> { (1..2).step(obj) { } }.should raise_error(TypeError)
end
it "raises a TypeError if #to_int does not return an Integer" do
obj = mock("Range#step non-integer")
obj.should_receive(:to_int).and_return("1")
-> { (1..2).step(obj) { } }.should raise_error(TypeError)
end
it "raises a TypeError if the first element does not respond to #succ" do
obj = mock("Range#step non-comparable")
obj.should_receive(:<=>).with(obj).and_return(1)
-> { (obj..obj).step { |x| x } }.should raise_error(TypeError)
end
end
it "calls #to_int to coerce step to an Integer" do
obj = mock("Range#step")
obj.should_receive(:to_int).and_return(1)
ruby_version_is "3.4" do
it "calls #coerce to coerce step to an Integer" do
obj = mock("Range#step")
obj.should_receive(:coerce).at_least(:once).and_return([1, 2])
(1..2).step(obj) { |x| ScratchPad << x }
ScratchPad.recorded.should eql([1, 2])
end
(1..3).step(obj) { |x| ScratchPad << x }
ScratchPad.recorded.should eql([1, 3])
end
it "raises a TypeError if step does not respond to #to_int" do
obj = mock("Range#step non-integer")
it "raises a TypeError if step does not respond to #coerce" do
obj = mock("Range#step non-coercible")
-> { (1..2).step(obj) { } }.should raise_error(TypeError)
end
it "raises a TypeError if #to_int does not return an Integer" do
obj = mock("Range#step non-integer")
obj.should_receive(:to_int).and_return("1")
-> { (1..2).step(obj) { } }.should raise_error(TypeError)
end
it "coerces the argument to integer by invoking to_int" do
(obj = mock("2")).should_receive(:to_int).and_return(2)
res = []
(1..10).step(obj) {|x| res << x}
res.should == [1, 3, 5, 7, 9]
end
it "raises a TypeError if the first element does not respond to #succ" do
obj = mock("Range#step non-comparable")
obj.should_receive(:<=>).with(obj).and_return(1)
-> { (obj..obj).step { |x| x } }.should raise_error(TypeError)
-> { (1..2).step(obj) { } }.should raise_error(TypeError)
end
end
it "raises an ArgumentError if step is 0" do
@ -58,8 +64,17 @@ describe "Range#step" do
-> { (-1..1).step(0.0) { |x| x } }.should raise_error(ArgumentError)
end
it "raises an ArgumentError if step is negative" do
-> { (-1..1).step(-2) { |x| x } }.should raise_error(ArgumentError)
ruby_version_is "3.4" do
it "does not raise an ArgumentError if step is 0 for non-numeric ranges" do
t = Time.utc(2023, 2, 24)
-> { (t..t+1).step(0) { break } }.should_not raise_error(ArgumentError)
end
end
ruby_version_is ""..."3.4" do
it "raises an ArgumentError if step is negative" do
-> { (-1..1).step(-2) { |x| x } }.should raise_error(ArgumentError)
end
end
describe "with inclusive end" do
@ -78,6 +93,18 @@ describe "Range#step" do
(-2..2).step(1.5) { |x| ScratchPad << x }
ScratchPad.recorded.should eql([-2.0, -0.5, 1.0])
end
ruby_version_is "3.4" do
it "does not iterate if step is negative for forward range" do
(-1..1).step(-1) { |x| ScratchPad << x }
ScratchPad.recorded.should eql([])
end
it "iterates backward if step is negative for backward range" do
(1..-1).step(-1) { |x| ScratchPad << x }
ScratchPad.recorded.should eql([1, 0, -1])
end
end
end
describe "and Float values" do
@ -148,27 +175,114 @@ describe "Range#step" do
end
describe "and String values" do
it "yields String values incremented by #succ and less than or equal to end when not passed a step" do
("A".."E").step { |x| ScratchPad << x }
ScratchPad.recorded.should == ["A", "B", "C", "D", "E"]
ruby_version_is ""..."3.4" do
it "yields String values incremented by #succ and less than or equal to end when not passed a step" do
("A".."E").step { |x| ScratchPad << x }
ScratchPad.recorded.should == ["A", "B", "C", "D", "E"]
end
it "yields String values incremented by #succ called Integer step times" do
("A".."G").step(2) { |x| ScratchPad << x }
ScratchPad.recorded.should == ["A", "C", "E", "G"]
end
it "raises a TypeError when passed a Float step" do
-> { ("A".."G").step(2.0) { } }.should raise_error(TypeError)
end
it "calls #succ on begin and each element returned by #succ" do
obj = mock("Range#step String start")
obj.should_receive(:<=>).exactly(3).times.and_return(-1, -1, -1, 0)
obj.should_receive(:succ).exactly(2).times.and_return(obj)
(obj..obj).step { |x| ScratchPad << x }
ScratchPad.recorded.should == [obj, obj, obj]
end
end
it "yields String values incremented by #succ called Integer step times" do
("A".."G").step(2) { |x| ScratchPad << x }
ScratchPad.recorded.should == ["A", "C", "E", "G"]
end
ruby_version_is "3.4" do
it "raises an ArgumentError when not passed a step" do
-> { ("A".."E").step { } }.should raise_error(ArgumentError)
end
it "raises a TypeError when passed a Float step" do
-> { ("A".."G").step(2.0) { } }.should raise_error(TypeError)
end
it "yields String values adjusted by step and less than or equal to end" do
("A".."AAA").step("A") { |x| ScratchPad << x }
ScratchPad.recorded.should == ["A", "AA", "AAA"]
end
it "calls #succ on begin and each element returned by #succ" do
obj = mock("Range#step String start")
obj.should_receive(:<=>).exactly(3).times.and_return(-1, -1, -1, 0)
obj.should_receive(:succ).exactly(2).times.and_return(obj)
it "raises a TypeError when passed an incompatible type step" do
-> { ("A".."G").step(2) { } }.should raise_error(TypeError)
end
(obj..obj).step { |x| ScratchPad << x }
ScratchPad.recorded.should == [obj, obj, obj]
it "calls #+ on begin and each element returned by #+" do
start = mock("Range#step String start")
stop = mock("Range#step String stop")
mid1 = mock("Range#step String mid1")
mid2 = mock("Range#step String mid2")
step = mock("Range#step String step")
# Deciding on the direction of iteration
start.should_receive(:<=>).with(stop).at_least(:twice).and_return(-1)
# Deciding whether the step moves iteration in the right direction
start.should_receive(:<=>).with(mid1).and_return(-1)
# Iteration 1
start.should_receive(:+).at_least(:once).with(step).and_return(mid1)
# Iteration 2
mid1.should_receive(:<=>).with(stop).and_return(-1)
mid1.should_receive(:+).with(step).and_return(mid2)
# Iteration 3
mid2.should_receive(:<=>).with(stop).and_return(0)
(start..stop).step(step) { |x| ScratchPad << x }
ScratchPad.recorded.should == [start, mid1, mid2]
end
it "iterates backward if the step is decreasing values, and the range is backward" do
start = mock("Range#step String start")
stop = mock("Range#step String stop")
mid1 = mock("Range#step String mid1")
mid2 = mock("Range#step String mid2")
step = mock("Range#step String step")
# Deciding on the direction of iteration
start.should_receive(:<=>).with(stop).at_least(:twice).and_return(1)
# Deciding whether the step moves iteration in the right direction
start.should_receive(:<=>).with(mid1).and_return(1)
# Iteration 1
start.should_receive(:+).at_least(:once).with(step).and_return(mid1)
# Iteration 2
mid1.should_receive(:<=>).with(stop).and_return(1)
mid1.should_receive(:+).with(step).and_return(mid2)
# Iteration 3
mid2.should_receive(:<=>).with(stop).and_return(0)
(start..stop).step(step) { |x| ScratchPad << x }
ScratchPad.recorded.should == [start, mid1, mid2]
end
it "does no iteration of the direction of the range and of the step don't match" do
start = mock("Range#step String start")
stop = mock("Range#step String stop")
mid1 = mock("Range#step String mid1")
mid2 = mock("Range#step String mid2")
step = mock("Range#step String step")
# Deciding on the direction of iteration: stop > start
start.should_receive(:<=>).with(stop).at_least(:twice).and_return(1)
# Deciding whether the step moves iteration in the right direction
# start + step < start, the direction is opposite to the range's
start.should_receive(:+).with(step).and_return(mid1)
start.should_receive(:<=>).with(mid1).and_return(-1)
(start..stop).step(step) { |x| ScratchPad << x }
ScratchPad.recorded.should == []
end
end
end
end
@ -266,18 +380,35 @@ describe "Range#step" do
end
describe "and String values" do
it "yields String values incremented by #succ and less than or equal to end when not passed a step" do
("A"..."E").step { |x| ScratchPad << x }
ScratchPad.recorded.should == ["A", "B", "C", "D"]
ruby_version_is ""..."3.4" do
it "yields String values incremented by #succ and less than or equal to end when not passed a step" do
("A"..."E").step { |x| ScratchPad << x }
ScratchPad.recorded.should == ["A", "B", "C", "D"]
end
it "yields String values incremented by #succ called Integer step times" do
("A"..."G").step(2) { |x| ScratchPad << x }
ScratchPad.recorded.should == ["A", "C", "E"]
end
it "raises a TypeError when passed a Float step" do
-> { ("A"..."G").step(2.0) { } }.should raise_error(TypeError)
end
end
it "yields String values incremented by #succ called Integer step times" do
("A"..."G").step(2) { |x| ScratchPad << x }
ScratchPad.recorded.should == ["A", "C", "E"]
end
ruby_version_is "3.4" do
it "raises an ArgumentError when not passed a step" do
-> { ("A".."E").step { } }.should raise_error(ArgumentError)
end
it "raises a TypeError when passed a Float step" do
-> { ("A"..."G").step(2.0) { } }.should raise_error(TypeError)
it "yields String values adjusted by step and less than or equal to end" do
("A"..."AAA").step("A") { |x| ScratchPad << x }
ScratchPad.recorded.should == ["A", "AA"]
end
it "raises a TypeError when passed an incompatible type step" do
-> { ("A".."G").step(2) { } }.should raise_error(TypeError)
end
end
end
end
@ -351,27 +482,49 @@ describe "Range#step" do
end
describe "and String values" do
it "yields String values incremented by #succ and less than or equal to end when not passed a step" do
eval("('A'..)").step { |x| break if x > "D"; ScratchPad << x }
ScratchPad.recorded.should == ["A", "B", "C", "D"]
ruby_version_is ""..."3.4" do
it "yields String values incremented by #succ and less than or equal to end when not passed a step" do
eval("('A'..)").step { |x| break if x > "D"; ScratchPad << x }
ScratchPad.recorded.should == ["A", "B", "C", "D"]
ScratchPad.record []
eval("('A'...)").step { |x| break if x > "D"; ScratchPad << x }
ScratchPad.recorded.should == ["A", "B", "C", "D"]
ScratchPad.record []
eval("('A'...)").step { |x| break if x > "D"; ScratchPad << x }
ScratchPad.recorded.should == ["A", "B", "C", "D"]
end
it "yields String values incremented by #succ called Integer step times" do
eval("('A'..)").step(2) { |x| break if x > "F"; ScratchPad << x }
ScratchPad.recorded.should == ["A", "C", "E"]
ScratchPad.record []
eval("('A'...)").step(2) { |x| break if x > "F"; ScratchPad << x }
ScratchPad.recorded.should == ["A", "C", "E"]
end
it "raises a TypeError when passed a Float step" do
-> { eval("('A'..)").step(2.0) { } }.should raise_error(TypeError)
-> { eval("('A'...)").step(2.0) { } }.should raise_error(TypeError)
end
end
it "yields String values incremented by #succ called Integer step times" do
eval("('A'..)").step(2) { |x| break if x > "F"; ScratchPad << x }
ScratchPad.recorded.should == ["A", "C", "E"]
ruby_version_is "3.4" do
it "raises an ArgumentError when not passed a step" do
-> { ("A"..).step { } }.should raise_error(ArgumentError)
end
ScratchPad.record []
eval("('A'...)").step(2) { |x| break if x > "F"; ScratchPad << x }
ScratchPad.recorded.should == ["A", "C", "E"]
end
it "yields String values adjusted by step" do
eval("('A'..)").step("A") { |x| break if x > "AAA"; ScratchPad << x }
ScratchPad.recorded.should == ["A", "AA", "AAA"]
it "raises a TypeError when passed a Float step" do
-> { eval("('A'..)").step(2.0) { } }.should raise_error(TypeError)
-> { eval("('A'...)").step(2.0) { } }.should raise_error(TypeError)
ScratchPad.record []
eval("('A'...)").step("A") { |x| break if x > "AAA"; ScratchPad << x }
ScratchPad.recorded.should == ["A", "AA", "AAA"]
end
it "raises a TypeError when passed an incompatible type step" do
-> { eval("('A'..)").step(2) { } }.should raise_error(TypeError)
-> { eval("('A'...)").step(2) { } }.should raise_error(TypeError)
end
end
end
end
@ -383,15 +536,24 @@ describe "Range#step" do
describe "returned Enumerator" do
describe "size" do
it "raises a TypeError if step does not respond to #to_int" do
obj = mock("Range#step non-integer")
-> { (1..2).step(obj) }.should raise_error(TypeError)
ruby_version_is ""..."3.4" do
it "raises a TypeError if step does not respond to #to_int" do
obj = mock("Range#step non-integer")
-> { (1..2).step(obj) }.should raise_error(TypeError)
end
it "raises a TypeError if #to_int does not return an Integer" do
obj = mock("Range#step non-integer")
obj.should_receive(:to_int).and_return("1")
-> { (1..2).step(obj) }.should raise_error(TypeError)
end
end
it "raises a TypeError if #to_int does not return an Integer" do
obj = mock("Range#step non-integer")
obj.should_receive(:to_int).and_return("1")
-> { (1..2).step(obj) }.should raise_error(TypeError)
ruby_version_is "3.4" do
it "does not raise if step is incompatible" do
obj = mock("Range#step non-integer")
-> { (1..2).step(obj) }.should_not raise_error
end
end
it "returns the ceil of range size divided by the number of steps" do
@ -431,19 +593,36 @@ describe "Range#step" do
(1.0...6.4).step(1.8).size.should == 3
end
it "returns nil with begin and end are String" do
("A".."E").step(2).size.should == nil
("A"..."E").step(2).size.should == nil
("A".."E").step.size.should == nil
("A"..."E").step.size.should == nil
ruby_version_is ""..."3.4" do
it "returns nil with begin and end are String" do
("A".."E").step(2).size.should == nil
("A"..."E").step(2).size.should == nil
("A".."E").step.size.should == nil
("A"..."E").step.size.should == nil
end
it "return nil and not raises a TypeError if the first element does not respond to #succ" do
obj = mock("Range#step non-comparable")
obj.should_receive(:<=>).with(obj).and_return(1)
enum = (obj..obj).step
-> { enum.size }.should_not raise_error
enum.size.should == nil
end
end
it "return nil and not raises a TypeError if the first element does not respond to #succ" do
obj = mock("Range#step non-comparable")
obj.should_receive(:<=>).with(obj).and_return(1)
enum = (obj..obj).step
-> { enum.size }.should_not raise_error
enum.size.should == nil
ruby_version_is "3.4" do
it "returns nil with begin and end are String" do
("A".."E").step("A").size.should == nil
("A"..."E").step("A").size.should == nil
end
it "return nil and not raises a TypeError if the first element is not of compatible type" do
obj = mock("Range#step non-comparable")
obj.should_receive(:<=>).with(obj).and_return(1)
enum = (obj..obj).step(obj)
-> { enum.size }.should_not raise_error
enum.size.should == nil
end
end
end
@ -470,22 +649,48 @@ describe "Range#step" do
(1..).step(2).take(3).should == [1, 3, 5]
end
it "returns an instance of Enumerator when begin is not numeric" do
("a"..).step.class.should == Enumerator
("a"..).step(2).take(3).should == %w[a c e]
ruby_version_is ""..."3.4" do
it "returns an instance of Enumerator when begin is not numeric" do
("a"..).step.class.should == Enumerator
("a"..).step(2).take(3).should == %w[a c e]
end
end
ruby_version_is "3.4" do
it "returns an instance of Enumerator when begin is not numeric" do
("a"..).step("a").class.should == Enumerator
("a"..).step("a").take(3).should == %w[a aa aaa]
end
end
end
context "when range is beginless and endless" do
it "returns an instance of Enumerator" do
Range.new(nil, nil).step.class.should == Enumerator
ruby_version_is ""..."3.4" do
it "returns an instance of Enumerator" do
Range.new(nil, nil).step.class.should == Enumerator
end
end
ruby_version_is "3.4" do
it "raises an ArgumentError" do
-> { Range.new(nil, nil).step(1) }.should raise_error(ArgumentError)
end
end
end
context "when begin and end are not numerics" do
it "returns an instance of Enumerator" do
("a".."z").step.class.should == Enumerator
("a".."z").step(3).take(4).should == %w[a d g j]
ruby_version_is ""..."3.4" do
it "returns an instance of Enumerator" do
("a".."z").step.class.should == Enumerator
("a".."z").step(3).take(4).should == %w[a d g j]
end
end
ruby_version_is "3.4" do
it "returns an instance of Enumerator" do
("a".."z").step("a").class.should == Enumerator
("a".."z").step("a").take(4).should == %w[a aa aaa aaaa]
end
end
end
end

2
test/ruby/test_dir.rb
Просмотреть файл

@ -256,7 +256,7 @@ class TestDir < Test::Unit::TestCase
Dir.glob(@root, sort: nil)
end
assert_equal(("a".."z").step(2).map {|f| File.join(File.join(@root, f), "") },
assert_equal(("a".."z").each_slice(2).map {|f,_| File.join(File.join(@root, f), "") },
Dir.glob(File.join(@root, "*/")))
assert_equal([File.join(@root, '//a')], Dir.glob(@root + '//a'))

284
test/ruby/test_range.rb
Просмотреть файл

@ -246,67 +246,138 @@ class TestRange < Test::Unit::TestCase
assert_kind_of(String, (0..1).hash.to_s)
end
def test_step
a = []
(0..10).step {|x| a << x }
assert_equal([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10], a)
def test_step_numeric_range
# Fixnums, floats and all other numbers (like rationals) should behave exactly the same,
# but the behavior is implemented independently in 3 different branches of code,
# so we need to test each of them.
%i[to_i to_r to_f].each do |type|
conv = type.to_proc
a = []
(0..).step {|x| a << x; break if a.size == 10 }
assert_equal([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], a)
from = conv.(0)
to = conv.(10)
step = conv.(2)
a = []
(0..10).step(2) {|x| a << x }
assert_equal([0, 2, 4, 6, 8, 10], a)
# finite
a = []
(from..to).step(step) {|x| a << x }
assert_equal([0, 2, 4, 6, 8, 10].map(&conv), a)
a = []
(0..).step(2) {|x| a << x; break if a.size == 10 }
assert_equal([0, 2, 4, 6, 8, 10, 12, 14, 16, 18], a)
a = []
(from...to).step(step) {|x| a << x }
assert_equal([0, 2, 4, 6, 8].map(&conv), a)
assert_kind_of(Enumerator::ArithmeticSequence, (0..10).step)
assert_kind_of(Enumerator::ArithmeticSequence, (0..10).step(2))
assert_kind_of(Enumerator::ArithmeticSequence, (0..10).step(0.5))
assert_kind_of(Enumerator::ArithmeticSequence, (10..0).step(-1))
assert_kind_of(Enumerator::ArithmeticSequence, (..10).step(2))
assert_kind_of(Enumerator::ArithmeticSequence, (1..).step(2))
# Note: ArithmeticSequence behavior tested in its own test, but we also put it here
# to demonstrate the result is the same
assert_kind_of(Enumerator::ArithmeticSequence, (from..to).step(step))
assert_equal([0, 2, 4, 6, 8, 10].map(&conv), (from..to).step(step).to_a)
assert_kind_of(Enumerator::ArithmeticSequence, (from...to).step(step))
assert_equal([0, 2, 4, 6, 8].map(&conv), (from...to).step(step).to_a)
assert_raise(ArgumentError) { (0..10).step(-1) { } }
assert_raise(ArgumentError) { (0..10).step(0) }
assert_raise(ArgumentError) { (0..10).step(0) { } }
assert_raise(ArgumentError) { (0..).step(-1) { } }
assert_raise(ArgumentError) { (0..).step(0) }
assert_raise(ArgumentError) { (0..).step(0) { } }
# endless
a = []
(from..).step(step) {|x| a << x; break if a.size == 5 }
assert_equal([0, 2, 4, 6, 8].map(&conv), a)
a = []
("a" .. "z").step(2) {|x| a << x }
assert_equal(%w(a c e g i k m o q s u w y), a)
assert_kind_of(Enumerator::ArithmeticSequence, (from..).step(step))
assert_equal([0, 2, 4, 6, 8].map(&conv), (from..).step(step).take(5))
a = []
("a" .. ).step(2) {|x| a << x; break if a.size == 13 }
assert_equal(%w(a c e g i k m o q s u w y), a)
# beginless
assert_raise(ArgumentError) { (..to).step(step) {} }
assert_kind_of(Enumerator::ArithmeticSequence, (..to).step(step))
# This is inconsistent, but so it is implemented by ArithmeticSequence
assert_raise(TypeError) { (..to).step(step).to_a }
a = []
("a" .. "z").step(2**32) {|x| a << x }
assert_equal(["a"], a)
# negative step
a = []
(:a .. :z).step(2) {|x| a << x }
assert_equal(%i(a c e g i k m o q s u w y), a)
a = []
(from..to).step(-step) {|x| a << x }
assert_equal([], a)
a = []
(:a .. ).step(2) {|x| a << x; break if a.size == 13 }
assert_equal(%i(a c e g i k m o q s u w y), a)
a = []
(from..-to).step(-step) {|x| a << x }
assert_equal([0, -2, -4, -6, -8, -10].map(&conv), a)
a = []
(:a .. :z).step(2**32) {|x| a << x }
assert_equal([:a], a)
a = []
(from...-to).step(-step) {|x| a << x }
assert_equal([0, -2, -4, -6, -8].map(&conv), a)
a = []
(from...).step(-step) {|x| a << x; break if a.size == 5 }
assert_equal([0, -2, -4, -6, -8].map(&conv), a)
assert_kind_of(Enumerator::ArithmeticSequence, (from..to).step(-step))
assert_equal([], (from..to).step(-step).to_a)
assert_kind_of(Enumerator::ArithmeticSequence, (from..-to).step(-step))
assert_equal([0, -2, -4, -6, -8, -10].map(&conv), (from..-to).step(-step).to_a)
assert_kind_of(Enumerator::ArithmeticSequence, (from...-to).step(-step))
assert_equal([0, -2, -4, -6, -8].map(&conv), (from...-to).step(-step).to_a)
assert_kind_of(Enumerator::ArithmeticSequence, (from...).step(-step))
assert_equal([0, -2, -4, -6, -8].map(&conv), (from...).step(-step).take(5))
# zero step
assert_raise(ArgumentError) { (from..to).step(0) {} }
assert_raise(ArgumentError) { (from..to).step(0) }
# default step
a = []
(from..to).step {|x| a << x }
assert_equal([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10].map(&conv), a)
assert_kind_of(Enumerator::ArithmeticSequence, (from..to).step)
assert_equal([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10].map(&conv), (from..to).step.to_a)
# default + endless range
a = []
(from..).step {|x| a << x; break if a.size == 5 }
assert_equal([0, 1, 2, 3, 4].map(&conv), a)
assert_kind_of(Enumerator::ArithmeticSequence, (from..).step)
assert_equal([0, 1, 2, 3, 4].map(&conv), (from..).step.take(5))
# default + beginless range
assert_kind_of(Enumerator::ArithmeticSequence, (..to).step)
# step is not numeric
to = conv.(5)
val = Struct.new(:val)
a = []
assert_raise(TypeError) { (from..to).step(val.new(step)) {|x| a << x } }
assert_kind_of(Enumerator, (from..to).step(val.new(step)))
assert_raise(TypeError) { (from..to).step(val.new(step)).to_a }
# step is not numeric, but coercible
val = Struct.new(:val) do
def coerce(num) = [self.class.new(num), self]
def +(other) = self.class.new(val + other.val)
def <=>(other) = other.is_a?(self.class) ? val <=> other.val : val <=> other
end
a = []
(from..to).step(val.new(step)) {|x| a << x }
assert_equal([from, val.new(conv.(2)), val.new(conv.(4))], a)
assert_kind_of(Enumerator, (from..to).step(val.new(step)))
assert_equal([from, val.new(conv.(2)), val.new(conv.(4))], (from..to).step(val.new(step)).to_a)
end
end
def test_step_numeric_fixnum_boundary
a = []
(2**32-1 .. 2**32+1).step(2) {|x| a << x }
assert_equal([4294967295, 4294967297], a)
zero = (2**32).coerce(0).first
assert_raise(ArgumentError) { (2**32-1 .. 2**32+1).step(zero) }
assert_raise(ArgumentError) { (2**32-1 .. 2**32+1).step(zero) { } }
a = []
(2**32-1 .. ).step(2) {|x| a << x; break if a.size == 2 }
assert_equal([4294967295, 4294967297], a)
@ -315,58 +386,85 @@ class TestRange < Test::Unit::TestCase
a = []
(max..).step {|x| a << x; break if a.size == 2 }
assert_equal([max, max+1], a)
a = []
(max..).step(max) {|x| a << x; break if a.size == 4 }
assert_equal([max, 2*max, 3*max, 4*max], a)
end
o1 = Object.new
o2 = Object.new
def o1.<=>(x); -1; end
def o2.<=>(x); 0; end
assert_raise(TypeError) { (o1..o2).step(1) { } }
assert_raise(TypeError) { (o1..).step(1) { } }
class << o1; self; end.class_eval do
define_method(:succ) { o2 }
end
a = []
(o1..o2).step(1) {|x| a << x }
assert_equal([o1, o2], a)
a = []
(o1...o2).step(1) {|x| a << x }
assert_equal([o1], a)
assert_nothing_raised("[ruby-dev:34557]") { (0..2).step(0.5) {|x| } }
a = []
(0..2).step(0.5) {|x| a << x }
assert_equal([0, 0.5, 1.0, 1.5, 2.0], a)
a = []
(0..).step(0.5) {|x| a << x; break if a.size == 5 }
assert_equal([0, 0.5, 1.0, 1.5, 2.0], a)
def test_step_big_float
a = []
(0x40000000..0x40000002).step(0.5) {|x| a << x }
assert_equal([1073741824, 1073741824.5, 1073741825.0, 1073741825.5, 1073741826], a)
end
o = Object.new
def o.to_int() 1 end
assert_nothing_raised("[ruby-dev:34558]") { (0..2).step(o) {|x| } }
def test_step_non_numeric_range
# finite
a = []
('a'..'aaaa').step('a') { a << _1 }
assert_equal(%w[a aa aaa aaaa], a)
o = Object.new
class << o
def to_str() "a" end
def <=>(other) to_str <=> other end
end
assert_kind_of(Enumerator, ('a'..'aaaa').step('a'))
assert_equal(%w[a aa aaa aaaa], ('a'..'aaaa').step('a').to_a)
a = []
(o.."c").step(1) {|x| a << x}
assert_equal(["a", "b", "c"], a)
('a'...'aaaa').step('a') { a << _1 }
assert_equal(%w[a aa aaa], a)
assert_kind_of(Enumerator, ('a'...'aaaa').step('a'))
assert_equal(%w[a aa aaa], ('a'...'aaaa').step('a').to_a)
# endless
a = []
(o..).step(1) {|x| a << x; break if a.size >= 3}
assert_equal(["a", "b", "c"], a)
('a'...).step('a') { a << _1; break if a.size == 3 }
assert_equal(%w[a aa aaa], a)
assert_kind_of(Enumerator, ('a'...).step('a'))
assert_equal(%w[a aa aaa], ('a'...).step('a').take(3))
# beginless
assert_raise(ArgumentError) { (...'aaa').step('a') {} }
assert_raise(ArgumentError) { (...'aaa').step('a') }
# step is not provided
assert_raise(ArgumentError) { ('a'...'aaaa').step }
# step is incompatible
assert_raise(TypeError) { ('a'...'aaaa').step(1) {} }
assert_raise(TypeError) { ('a'...'aaaa').step(1).to_a }
# step is compatible, but shouldn't convert into numeric domain:
a = []
(Time.utc(2022, 2, 24)...).step(1) { a << _1; break if a.size == 2 }
assert_equal([Time.utc(2022, 2, 24), Time.utc(2022, 2, 24, 0, 0, 1)], a)
a = []
(Time.utc(2022, 2, 24)...).step(1.0) { a << _1; break if a.size == 2 }
assert_equal([Time.utc(2022, 2, 24), Time.utc(2022, 2, 24, 0, 0, 1)], a)
a = []
(Time.utc(2022, 2, 24)...).step(1r) { a << _1; break if a.size == 2 }
assert_equal([Time.utc(2022, 2, 24), Time.utc(2022, 2, 24, 0, 0, 1)], a)
# step decreases the value
a = []
(Time.utc(2022, 2, 24)...).step(-1) { a << _1; break if a.size == 2 }
assert_equal([Time.utc(2022, 2, 24), Time.utc(2022, 2, 23, 23, 59, 59)], a)
a = []
(Time.utc(2022, 2, 24)...Time.utc(2022, 2, 23, 23, 59, 57)).step(-1) { a << _1 }
assert_equal([Time.utc(2022, 2, 24), Time.utc(2022, 2, 23, 23, 59, 59),
Time.utc(2022, 2, 23, 23, 59, 58)], a)
a = []
(Time.utc(2022, 2, 24)..Time.utc(2022, 2, 23, 23, 59, 57)).step(-1) { a << _1 }
assert_equal([Time.utc(2022, 2, 24), Time.utc(2022, 2, 23, 23, 59, 59),
Time.utc(2022, 2, 23, 23, 59, 58), Time.utc(2022, 2, 23, 23, 59, 57)], a)
# step decreases, but the range is forward-directed:
a = []
(Time.utc(2022, 2, 24)...Time.utc(2022, 2, 24, 01, 01, 03)).step(-1) { a << _1 }
assert_equal([], a)
end
def test_step_bug15537
@ -392,26 +490,6 @@ class TestRange < Test::Unit::TestCase
assert_equal(4, (1.0...5.6).step(1.5).to_a.size)
end
def test_step_with_succ
c = Struct.new(:i) do
def succ; self.class.new(i+1); end
def <=>(other) i <=> other.i;end
end.new(0)
result = []
(c..c.succ).step(2) do |d|
result << d.i
end
assert_equal([0], result)
result = []
(c..).step(2) do |d|
result << d.i
break if d.i >= 4
end
assert_equal([0, 2, 4], result)
end
def test_each
a = []
(0..10).each {|x| a << x }

1
tool/rbs_skip_tests
Просмотреть файл

@ -16,6 +16,7 @@
#
test_replicate(EncodingTest) the method was removed in 3.3
test_step(RangeTest) the method protocol was changed in 3.4
test_collection_install(RBS::CliTest) running tests without Bundler
test_collection_install_frozen(RBS::CliTest) running tests without Bundler