Improved exception usage/classes.

4 files changed, 49 insertions, 38 deletions

diff --git a/file.c b/file.c
index b073051944..829d6d513d 100644
--- a/file.c
+++ b/file.c
@@ -2518,19 +2518,23 @@ rb_file_birthtime(VALUE obj)
 off_t
 rb_file_size(VALUE file)
 {
-    rb_io_t *fptr;
-    struct stat st;
+    if (RB_TYPE_P(file, T_FILE)) {
+        rb_io_t *fptr;
+        struct stat st;
 
-    RB_IO_POINTER(file, fptr);
-    if (fptr->mode & FMODE_WRITABLE) {
-        rb_io_flush_raw(file, 0);
-    }
+        RB_IO_POINTER(file, fptr);
+        if (fptr->mode & FMODE_WRITABLE) {
+            rb_io_flush_raw(file, 0);
+        }
 
-    if (fstat(fptr->fd, &st) == -1) {
-        rb_sys_fail_path(fptr->pathv);
-    }
+        if (fstat(fptr->fd, &st) == -1) {
+            rb_sys_fail_path(fptr->pathv);
+        }
 
-    return st.st_size;
+        return st.st_size;
+    } else {
+        return NUM2OFFT(rb_funcall(file, idSize, 0));
+    }
 }
 
 static VALUE
diff --git a/include/ruby/internal/intern/file.h b/include/ruby/internal/intern/file.h
index 7a6af99872..2dc60c7ba7 100644
--- a/include/ruby/internal/intern/file.h
+++ b/include/ruby/internal/intern/file.h
@@ -198,6 +198,8 @@ int rb_is_absolute_path(const char *path);
  * @exception   rb_eFrozenError      `file` is frozen.
  * @exception   rb_eIOError          `file` is closed.
  * @exception   rb_eSystemCallError  Permission denied etc.
+ * @exception   rb_eNoMethodError    The given non-file object doesn't respond
+ *                                   to `#size`.
  * @return      The size of the passed file.
  * @note        Passing a non-regular file such as a UNIX domain socket to this
  *              function  is   not  a  failure.    But  the  return   value  is
diff --git a/io_buffer.c b/io_buffer.c
index d2a12b98fb..cc022a7c9f 100644
--- a/io_buffer.c
+++ b/io_buffer.c
@@ -14,6 +14,11 @@
 #include "internal/error.h"
 
 VALUE rb_cIOBuffer;
+VALUE rb_eIOBufferLockedError;
+VALUE rb_eIOBufferAllocationError;
+VALUE rb_eIOBufferMutationError;
+VALUE rb_eIOBufferInvalidatedError;
+
 size_t RUBY_IO_BUFFER_PAGE_SIZE;
 size_t RUBY_IO_BUFFER_DEFAULT_SIZE;
 
@@ -163,7 +168,7 @@ io_buffer_initialize(struct rb_io_buffer *data, void *base, size_t size, enum rb
     }
 
     if (!data->base) {
-        rb_raise(rb_eRuntimeError, "Could not allocate buffer!");
+        rb_raise(rb_eIOBufferAllocationError, "Could not allocate buffer!");
     }
 
     data->source = source;
@@ -327,9 +332,6 @@ io_buffer_map(int argc, VALUE *argv, VALUE klass)
     }
 
     VALUE io = argv[0];
-    if (!RB_TYPE_P(io, T_FILE)) {
-        rb_raise(rb_eArgError, "Must be file/io!");
-    }
 
     size_t size;
     if (argc >= 2) {
@@ -622,7 +624,7 @@ rb_io_buffer_lock(VALUE self)
     TypedData_Get_Struct(self, struct rb_io_buffer, &rb_io_buffer_type, data);
 
     if (data->flags & RB_IO_BUFFER_LOCKED) {
-        rb_raise(rb_eRuntimeError, "Buffer already locked!");
+        rb_raise(rb_eIOBufferLockedError, "Buffer already locked!");
     }
 
     data->flags |= RB_IO_BUFFER_LOCKED;
@@ -637,7 +639,7 @@ rb_io_buffer_unlock(VALUE self)
     TypedData_Get_Struct(self, struct rb_io_buffer, &rb_io_buffer_type, data);
 
     if (!(data->flags & RB_IO_BUFFER_LOCKED)) {
-        rb_raise(rb_eRuntimeError, "Buffer not locked!");
+        rb_raise(rb_eIOBufferLockedError, "Buffer not locked!");
     }
 
     data->flags &= ~RB_IO_BUFFER_LOCKED;
@@ -652,7 +654,7 @@ rb_io_buffer_locked(VALUE self)
     TypedData_Get_Struct(self, struct rb_io_buffer, &rb_io_buffer_type, data);
 
     if (data->flags & RB_IO_BUFFER_LOCKED) {
-        rb_raise(rb_eRuntimeError, "Buffer already locked!");
+        rb_raise(rb_eIOBufferLockedError, "Buffer already locked!");
     }
 
     data->flags |= RB_IO_BUFFER_LOCKED;
@@ -671,7 +673,7 @@ rb_io_buffer_free(VALUE self)
     TypedData_Get_Struct(self, struct rb_io_buffer, &rb_io_buffer_type, data);
 
     if (data->flags & RB_IO_BUFFER_LOCKED) {
-        rb_raise(rb_eRuntimeError, "Buffer is locked!");
+        rb_raise(rb_eIOBufferLockedError, "Buffer is locked!");
     }
 
     io_buffer_free(data);
@@ -683,7 +685,7 @@ static inline void
 rb_io_buffer_validate(struct rb_io_buffer *data, size_t offset, size_t length)
 {
     if (offset + length > data->size) {
-        rb_raise(rb_eRuntimeError, "Specified offset + length exceeds source size!");
+        rb_raise(rb_eArgError, "Specified offset + length exceeds source size!");
     }
 }
 
@@ -751,11 +753,11 @@ rb_io_buffer_get_mutable(VALUE self, void **base, size_t *size)
     TypedData_Get_Struct(self, struct rb_io_buffer, &rb_io_buffer_type, data);
 
     if (data->flags & RB_IO_BUFFER_IMMUTABLE) {
-        rb_raise(rb_eRuntimeError, "Buffer is immutable!");
+        rb_raise(rb_eIOBufferMutationError, "Buffer is immutable!");
     }
 
     if (!io_buffer_validate(data)) {
-        rb_raise(rb_eRuntimeError, "Buffer has been invalidated!");
+        rb_raise(rb_eIOBufferInvalidatedError, "Buffer has been invalidated!");
     }
 
     if (data && data->base) {
@@ -765,7 +767,7 @@ rb_io_buffer_get_mutable(VALUE self, void **base, size_t *size)
         return;
     }
 
-    rb_raise(rb_eRuntimeError, "Buffer is not allocated!");
+    rb_raise(rb_eIOBufferAllocationError, "Buffer is not allocated!");
 }
 
 void
@@ -775,7 +777,7 @@ rb_io_buffer_get_immutable(VALUE self, const void **base, size_t *size)
     TypedData_Get_Struct(self, struct rb_io_buffer, &rb_io_buffer_type, data);
 
     if (!io_buffer_validate(data)) {
-        rb_raise(rb_eRuntimeError, "Buffer has been invalidated!");
+        rb_raise(rb_eIOBufferInvalidatedError, "Buffer has been invalidated!");
     }
 
     if (data && data->base) {
@@ -785,7 +787,7 @@ rb_io_buffer_get_immutable(VALUE self, const void **base, size_t *size)
         return;
     }
 
-    rb_raise(rb_eRuntimeError, "Buffer is not allocated!");
+    rb_raise(rb_eIOBufferAllocationError, "Buffer is not allocated!");
 }
 
 size_t
@@ -798,7 +800,7 @@ rb_io_buffer_copy(VALUE self, VALUE source, size_t offset)
     TypedData_Get_Struct(self, struct rb_io_buffer, &rb_io_buffer_type, data);
 
     if (data->flags & RB_IO_BUFFER_IMMUTABLE) {
-        rb_raise(rb_eRuntimeError, "Buffer is immutable!");
+        rb_raise(rb_eIOBufferMutationError, "Buffer is immutable!");
     }
 
     if (RB_TYPE_P(source, T_STRING)) {
@@ -830,7 +832,7 @@ rb_io_buffer_transfer(VALUE self)
     TypedData_Get_Struct(self, struct rb_io_buffer, &rb_io_buffer_type, data);
 
     if (data->flags & RB_IO_BUFFER_LOCKED) {
-        rb_raise(rb_eRuntimeError, "Cannot transfer ownership of locked buffer!");
+        rb_raise(rb_eIOBufferLockedError, "Cannot transfer ownership of locked buffer!");
     }
 
     VALUE instance = rb_io_buffer_type_allocate(rb_class_of(self));
@@ -877,7 +879,7 @@ rb_io_buffer_resize(VALUE self, size_t size)
     TypedData_Get_Struct(self, struct rb_io_buffer, &rb_io_buffer_type, data);
 
     if (data->flags & RB_IO_BUFFER_LOCKED) {
-        rb_raise(rb_eRuntimeError, "Cannot resize locked buffer!");
+        rb_raise(rb_eIOBufferLockedError, "Cannot resize locked buffer!");
     }
 
     if (data->base == NULL) {
@@ -886,7 +888,7 @@ rb_io_buffer_resize(VALUE self, size_t size)
     }
 
     if (io_buffer_external_p(data->flags)) {
-        rb_raise(rb_eRuntimeError, "Cannot resize external buffer!");
+        rb_raise(rb_eIOBufferMutationError, "Cannot resize external buffer!");
     }
 
 #ifdef MREMAP_MAYMOVE
@@ -956,7 +958,7 @@ static void
 io_buffer_validate_type(size_t size, size_t offset)
 {
     if (offset > size) {
-        rb_raise(rb_eRuntimeError, "Type extends beyond end of buffer!");
+        rb_raise(rb_eArgError, "Type extends beyond end of buffer!");
     }
 }
 
@@ -1151,7 +1153,7 @@ rb_io_buffer_clear(VALUE self, uint8_t value, size_t offset, size_t length)
     rb_io_buffer_get_mutable(self, &base, &size);
 
     if (offset + length > size) {
-        rb_raise(rb_eRuntimeError, "Offset + length out of bounds!");
+        rb_raise(rb_eArgError, "The given offset + length out of bounds!");
     }
 
     memset((char*)base + offset, value, length);
@@ -1215,6 +1217,10 @@ void
 Init_IO_Buffer(void)
 {
     rb_cIOBuffer = rb_define_class_under(rb_cIO, "Buffer", rb_cObject);
+    rb_eIOBufferLockedError = rb_define_class_under(rb_cIOBuffer, "LockedError", rb_eRuntimeError);
+    rb_eIOBufferAllocationError = rb_define_class_under(rb_cIOBuffer, "AllocationError", rb_eRuntimeError);
+    rb_eIOBufferMutationError = rb_define_class_under(rb_cIOBuffer, "MutationError", rb_eRuntimeError);
+    rb_eIOBufferInvalidatedError = rb_define_class_under(rb_cIOBuffer, "InvalidatedError", rb_eRuntimeError);
 
     rb_define_alloc_func(rb_cIOBuffer, rb_io_buffer_type_allocate);
     rb_define_singleton_method(rb_cIOBuffer, "for", rb_io_buffer_type_for, 1);
diff --git a/test/ruby/test_io_buffer.rb b/test/ruby/test_io_buffer.rb
index 76fa1bd774..9c989f5cfe 100644
--- a/test/ruby/test_io_buffer.rb
+++ b/test/ruby/test_io_buffer.rb
@@ -60,11 +60,11 @@ class TestIOBuffer < Test::Unit::TestCase
     buffer = IO::Buffer.new(128, IO::Buffer::INTERNAL|IO::Buffer::IMMUTABLE)
     assert buffer.immutable?
 
-    assert_raise RuntimeError do
+    assert_raise IO::Buffer::MutationError do
       buffer.copy("", 0)
     end
 
-    assert_raise RuntimeError do
+    assert_raise IO::Buffer::MutationError do
       buffer.copy("!", 1)
     end
   end
@@ -75,7 +75,7 @@ class TestIOBuffer < Test::Unit::TestCase
   end
 
   def test_file_mapped_invalid
-    assert_raise ArgumentError do
+    assert_raise NoMethodError do
       IO::Buffer.map("foobar")
     end
   end
@@ -163,8 +163,7 @@ class TestIOBuffer < Test::Unit::TestCase
   def test_slice_bounds
     buffer = IO::Buffer.new(128)
 
-    # What is best exception class?
-    assert_raise RuntimeError do
+    assert_raise ArgumentError do
       buffer.slice(128, 10)
     end
 
@@ -176,13 +175,13 @@ class TestIOBuffer < Test::Unit::TestCase
   def test_locked
     buffer = IO::Buffer.new(128, IO::Buffer::INTERNAL|IO::Buffer::LOCKED)
 
-    assert_raise RuntimeError do
+    assert_raise IO::Buffer::LockedError do
       buffer.resize(256)
     end
 
     assert_equal 128, buffer.size
 
-    assert_raise RuntimeError do
+    assert_raise IO::Buffer::LockedError do
       buffer.free
     end
 
@@ -203,7 +202,7 @@ class TestIOBuffer < Test::Unit::TestCase
 
     # (4) scheduler returns
     # (5) rb_write_internal invalidate the buffer object
-    assert_raise RuntimeError do
+    assert_raise IO::Buffer::LockedError do
       buffer.free
     end