Ruby » Ruby master

Tue Nov 27 22:03:09 2012 Akinori MUSHA <knu@iDaemons.org>

* string.c (rb_str_enumerate_chars, rb_str_enumerate_codepoints)

* extended method:

* Hash#default_proc= can be passed nil to clear the default proc.

* Kernel

* added method:

* added Kernel#Hash conversion method like Array() or Float().

* Shellwords#shelljoin() accepts non-string objects in the given

array, each of which is stringified using to_s.

* syslog

* Added Syslog::Logger which provides a Logger API atop Syslog.

* Syslog::Priority, Syslog::Level, Syslog::Option and Syslog::Macros

* Added support for the new deflate strategies Zlib::RLE and Zlib::FIXED.

* Zlib streams are now processed without the GVL. This allows gzip, zlib and

deflate streams to be processed in parallel.

=== Language changes

works because str.lines returns an array. Replace lines with

each_line in such cases.

* Signal.trap

See above.

/*

* call-seq:

* strio.each_byte {|byte| block } -> strio

* strio.each_byte -> anEnumerator

*

}

/*

* call-seq:

* strio.getc -> string or nil

*

/*

* call-seq:

* strio.each_char {|char| block } -> strio

* strio.each_char -> anEnumerator

*

}

/*

* call-seq:

* strio.each_codepoint {|c| block } -> strio

* strio.each_codepoint -> anEnumerator

*

return self;

}

/* Boyer-Moore search: copied from regex.c */

static void

bm_init_skip(long *skip, const char *pat, long m)

* strio.each_line(sep,limit) {|line| block } -> strio

* strio.each_line(...) -> anEnumerator

*

* See IO#each.

*/

static VALUE

}

/*

* call-seq:

* strio.readlines(sep=$/) -> array

* strio.readlines(limit) -> array

rb_define_method(StringIO, "each", strio_each, -1);

rb_define_method(StringIO, "each_line", strio_each, -1);

rb_define_method(StringIO, "each_byte", strio_each_byte, 0);

rb_define_method(StringIO, "each_char", strio_each_char, 0);

rb_define_method(StringIO, "each_codepoint", strio_each_codepoint, 0);

rb_define_method(StringIO, "getc", strio_getc, 0);

rb_define_method(StringIO, "ungetc", strio_ungetc, 1);

rb_define_method(StringIO, "ungetbyte", strio_ungetbyte, 1);

}

/*

* Document-method: Zlib::GzipReader#ungetc

*

* See Zlib::GzipReader documentation for a description.

}

/*

* Document-method: Zlib::GzipReader#readlines

*

* See Zlib::GzipReader documentation for a description.

rb_define_method(cGzipReader, "readbyte", rb_gzreader_readbyte, 0);

rb_define_method(cGzipReader, "each_byte", rb_gzreader_each_byte, 0);

rb_define_method(cGzipReader, "each_char", rb_gzreader_each_char, 0);

rb_define_method(cGzipReader, "ungetc", rb_gzreader_ungetc, 1);

rb_define_method(cGzipReader, "ungetbyte", rb_gzreader_ungetbyte, 1);

rb_define_method(cGzipReader, "gets", rb_gzreader_gets, -1);

rb_define_method(cGzipReader, "readline", rb_gzreader_readline, -1);

rb_define_method(cGzipReader, "each", rb_gzreader_each, -1);

rb_define_method(cGzipReader, "each_line", rb_gzreader_each, -1);

rb_define_method(cGzipReader, "readlines", rb_gzreader_readlines, -1);

/* The OS code of current host */

* ios.each_line(sep,limit) {|line| block } -> ios

* ios.each_line(...) -> an_enumerator

*

* Executes the block for every line in <em>ios</em>, where lines are

* separated by <i>sep</i>. <em>ios</em> must be opened for

* reading or an <code>IOError</code> will be raised.

}

/*

* call-seq:

* ios.each_byte {|byte| block } -> ios

* ios.each_byte -> an_enumerator

*

return io;

}

static VALUE

io_getc(rb_io_t *fptr, rb_encoding *enc)

{

/*

* call-seq:

* ios.each_char {|c| block } -> ios

* ios.each_char -> an_enumerator

*

return io;

}

/*

* call-seq:

return io;

}

/*

* ARGF.each_line(sep=$/,limit) {|line| block } -> ARGF

* ARGF.each_line(...) -> an_enumerator

*

* Returns an enumerator which iterates over each line (separated by _sep_,

* which defaults to your platform's newline character) of each file in

* +ARGV+. If a block is supplied, each line in turn will be yielded to the

}

/*

* call-seq:

* ARGF.bytes {|byte| block } -> ARGF

* ARGF.bytes -> an_enumerator

}

/*

* call-seq:

* ARGF.each_char {|char| block } -> ARGF

* ARGF.each_char -> an_enumerator

*

}

/*

* call-seq:

* ARGF.each_codepoint {|codepoint| block } -> ARGF

* ARGF.each_codepoint -> an_enumerator

*

}

/*

* call-seq:

* ARGF.filename -> String

* ARGF.path -> String

rb_define_method(rb_cIO, "each_byte", rb_io_each_byte, 0);

rb_define_method(rb_cIO, "each_char", rb_io_each_char, 0);

rb_define_method(rb_cIO, "each_codepoint", rb_io_each_codepoint, 0);

rb_define_method(rb_cIO, "syswrite", rb_io_syswrite, 1);

rb_define_method(rb_cIO, "sysread", rb_io_sysread, -1);

rb_define_method(rb_cARGF, "each_byte", argf_each_byte, 0);

rb_define_method(rb_cARGF, "each_char", argf_each_char, 0);

rb_define_method(rb_cARGF, "each_codepoint", argf_each_codepoint, 0);

rb_define_method(rb_cARGF, "read", argf_read, -1);

rb_define_method(rb_cARGF, "readpartial", argf_readpartial, -1);

assert_ruby_status(["-e", "2.times {STDIN.tty?; readlines}"], "", bug5952)

end

def test_bytes

print Marshal.dump(ARGF.bytes.to_a)

SRC

assert_equal([49, 10, 50, 10, 51, 10, 52, 10, 53, 10, 54, 10], Marshal.load(f.read))

end

end

def test_chars

print [Marshal.dump(ARGF.chars.to_a)].pack('m')

SRC

assert_equal(["1", "\n", "2", "\n", "3", "\n", "4", "\n", "5", "\n", "6", "\n"], Marshal.load(f.read.unpack('m').first))

end

end

def test_codepoints

print Marshal.dump(ARGF.codepoints.to_a)

SRC

assert_equal([49, 10, 50, 10, 51, 10, 52, 10, 53, 10, 54, 10], Marshal.load(f.read))

end

end

}

end

def test_rubydev33072

t = make_tempfile

path = t.path

end

def test_lines

pipe(proc do |w|

w.puts "foo"

w.puts "bar"

w.puts "baz"

w.close

end, proc do |r|

assert_equal("foo\n", e.next)

assert_equal("bar\n", e.next)

assert_equal("baz\n", e.next)

assert_raise(StopIteration) { e.next }

end)

end

def test_bytes

pipe(proc do |w|

w.binmode

w.puts "foo"

w.puts "baz"

w.close

end, proc do |r|

(%w(f o o) + ["\n"] + %w(b a r) + ["\n"] + %w(b a z) + ["\n"]).each do |c|

assert_equal(c.ord, e.next)

end

assert_raise(StopIteration) { e.next }

end)

end

def test_chars

pipe(proc do |w|

w.puts "foo"

w.puts "bar"

w.puts "baz"

w.close

end, proc do |r|

(%w(f o o) + ["\n"] + %w(b a r) + ["\n"] + %w(b a z) + ["\n"]).each do |c|

assert_equal(c, e.next)

end

assert_raise(StopIteration) { e.next }

end)

end

def test_readbyte