mouse 3.0.0 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e81909b0a768cd68bb57c1fb51e957cc94d4a5dc
-  data.tar.gz: 20450a678f6e938de48df53e9d165832df06f5c3
+  metadata.gz: 2ddfe16e59a8a567e6ebd72a64bde83a5975b70a
+  data.tar.gz: 5903fd9b63b5071d4076d71a67ab30fd32bee76f
 SHA512:
-  metadata.gz: 6df452f27bff39f031bfcf620c19a1bcc7d07ead593d2bf0978865d6c0c7da079c80677f3851236457acae952ffe3c3284d49aae003dcb557a0c3042c46d8046
-  data.tar.gz: 04b9727b98e30a3594a664a675a8c87f3d4ccd951c3c376e71226e89c4dcbb02fdf4a87d12cd1a156aba758e81aa87c97863d61830d0ea7622202c81c515321d
+  metadata.gz: d0cc22ad9e05aa6a5b4aed1619b505be16204a9a961cae862b7fcf6e0ef42ef42506d9791a59e8729faf5db0043e470403566114aab54f043b79cf9f96e21830
+  data.tar.gz: ad82dcd3fff38d40cf33803a1db0adbd037a4b96b44dbbadf4355ee915c436372d05d55734e2d992d32cdaa14f451ee746dbbc91ec437da2b3bb8a723079c272

checksums.yaml.gz.sig

@@ -0,0 +1,2 @@
+Kp����6�X��⼐�J
�j������!TD��Qh��{���v��?�e���a��!���ξ��e�f�2�)q�5_���!k�u���†r�߲����7���l�f��������g	�5�.��:��
���ufu��}s|(C\}?����uw�
+�~ʸ:�>�𖹍�%�:�%�x+DY�{���l��̈́Vmv�K߳�}�{�\��ܖ+$z;B�w�L����W�'�N3c����'z�~�!�$-�

data/History.markdown

@@ -1,3 +1,11 @@
+# 4.0.0 - Scaling Yosemite
+
+  * Finish removing MacRuby support
+  * Cleanup coding style and doocumentation, and also enable stricter warnings
+  * Begin signing the gem
+  * Begin distributing pre-compiled versions of the gem
+  * Yosemite compatability
+
 # 3.0.0 - The death of MacRuby
 
   * Remove MacRuby support (sort of)

data/README.markdown

@@ -15,6 +15,8 @@ testing; this is the purpose of the
 
 [![Code Climate](https://codeclimate.com/github/AXElements/mouse.png)](https://codeclimate.com/github/AXElements/mouse)
 [![Dependency Status](https://gemnasium.com/AXElements/mouse.png)](https://gemnasium.com/AXElements/mouse)
+[![Gem Version](https://badge.fury.io/rb/mouse.svg)](http://badge.fury.io/rb/mouse)
+[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/AXElements/mouse/trend.png)](https://bitdeli.com/free "Bitdeli Badge")
 
 
 ## Examples
@@ -91,9 +93,20 @@ change in the future if there are enough complaints.
 - [ ] Import test app and specialize so we can have better tests
 
 
+## Security
+
+mouse is cryptographically signed. To be sure the gem you install
+hasn’t been tampered with you will want to add my public key (if you
+haven’t already) as a trusted certificate for Rubygems:
+
+```sh
+gem cert --add <(curl -Ls https://raw.github.com/AXElements/mouse/master/certs/markrada26@gmail.com.pem)
+gem install mouse -P HighSecurity
+```
+
 ## Copyright
 
-Copyright (c) 2012-2013, Mark Rada
+Copyright (c) 2012-2015, Mark Rada
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without

data/Rakefile

@@ -1,15 +1,15 @@
-task :default => :test
+task default: :test
 
 require 'rake/clean'
-CLEAN.include '*.plist', '*.gch'
+CLOBBER.include '*.plist', '*.gch'
 
 desc 'Run the Clang static analyzer'
 task :analyze do
-  sh "clang --analyze ext/mouse/mouser.c"
+  sh 'clang --analyze ext/mouse/mouser.c'
 end
 
 desc 'Startup an IRb console with Mouse loaded'
-task :console => [:compile] do
+task console: :compile do
   sh 'irb -Ilib -rmouse'
 end
 
@@ -18,24 +18,23 @@ Rake::TestTask.new do |t|
   t.libs << '.'
   t.pattern = 'test/*_test.rb'
 end
-task :test => :compile
-
+task test: :compile
 
 # Gem stuff
 
 require 'rubygems/package_task'
 mouse_spec = Gem::Specification.load('mouse.gemspec')
 
-Gem::PackageTask.new(mouse_spec) { }
-
-desc 'Build and install gem (not including deps)'
-task :install => :gem do
-  require 'rubygems/installer'
-  Gem::Installer.new("pkg/#{mouse_spec.file_name}").install
-end
+Gem::PackageTask.new(mouse_spec) {}
 
 require 'rake/extensiontask'
 Rake::ExtensionTask.new('mouse', mouse_spec) do |t|
   t.lib_dir = 'lib/mouse'
+  t.ext_dir = 'ext/mouse'
 end
 
+desc 'Build and install gem (not including deps)'
+task install: :gem do
+  require 'rubygems/installer'
+  Gem::Installer.new("pkg/#{mouse_spec.file_name}").install
+end

data/ext/mouse/extconf.rb

@@ -1,24 +1,19 @@
 require 'mkmf'
 
-$CFLAGS << ' -std=c99 -Wall -Werror -pedantic'
-$LIBS   << ' -framework Foundation -framework ApplicationServices'
-$LIBS   << ' -framework CoreGraphics' unless `sw_vers -productVersion`.to_f == 10.7
+$CFLAGS << ' -std=c99 -Weverything'
+$CFLAGS << ' -Wno-disabled-macro-expansion -Wno-gnu -Wno-documentation'
+# @todo REALLY NEED TO CLEAR ALL THESE WARNINGS
+$CFLAGS << ' -Wno-conversion'
 
-if RUBY_ENGINE == 'macruby'
-  $LIBS << ' -framework Cocoa'
-  $CFLAGS << ' -ObjC -fobjc-gc'
-else
-  unless RbConfig::CONFIG["CC"].match /clang/
-    clang = `which clang`.chomp
-    if clang.empty?
-      $stdout.puts "Clang not installed. Cannot build C extension"
-      raise "Clang not installed. Cannot build C extension"
-    else
-      RbConfig::MAKEFILE_CONFIG["CC"]  = clang
-      RbConfig::MAKEFILE_CONFIG["CXX"] = clang
-    end
-  end
-  $CFLAGS << ' -DNOT_MACRUBY'
+$LIBS   << ' -framework Foundation'
+$LIBS   << ' -framework ApplicationServices'
+$LIBS   << ' -framework CoreGraphics'
+
+unless RbConfig::CONFIG['CC'].match(/clang/)
+  clang = `which clang`.chomp
+  fail 'Clang not installed. Cannot build C extension' if clang.empty?
+  RbConfig::MAKEFILE_CONFIG['CC']  = clang
+  RbConfig::MAKEFILE_CONFIG['CXX'] = clang
 end
 
 create_makefile 'mouse/mouse'

data/ext/mouse/mouse.c

@@ -1,6 +1,11 @@
 #include "mouser.h"
 #include "ruby.h"
 
+#ifndef UNUSED
+#define UNUSED __attribute__ ((unused))
+#endif
+
+
 static VALUE rb_mMouse, rb_cCGPoint;
 
 static ID sel_x, sel_y, sel_to_point, sel_new;
@@ -15,32 +20,19 @@ static VALUE sym_pixel, sym_line,
 
 static
 VALUE
-rb_mouse_wrap_point(CGPoint point)
+rb_mouse_wrap_point(const CGPoint point)
 {
-#if NOT_MACRUBY
-  return rb_struct_new(rb_cCGPoint, DBL2NUM(point.x), DBL2NUM(point.y));
-#else
-  return rb_funcall(rb_cCGPoint, sel_new, 2, DBL2NUM(point.x), DBL2NUM(point.y));
-#endif
+    return rb_struct_new(rb_cCGPoint, DBL2NUM(point.x), DBL2NUM(point.y));
 }
 
 static
 CGPoint
-rb_mouse_unwrap_point(VALUE point)
+rb_mouse_unwrap_point(const VALUE maybe_point)
 {
-  point = rb_funcall(point, sel_to_point, 0);
-
-#if NOT_MACRUBY
-  double x = NUM2DBL(rb_struct_getmember(point, sel_x));
-  double y = NUM2DBL(rb_struct_getmember(point, sel_y));
-  return CGPointMake(x, y);
-
-#else
-  CGPoint* ptr;
-  Data_Get_Struct(point, CGPoint, ptr);
-  return *ptr;
-
-#endif
+    const VALUE point = rb_funcall(maybe_point, sel_to_point, 0);
+    const double x = NUM2DBL(rb_struct_getmember(point, sel_x));
+    const double y = NUM2DBL(rb_struct_getmember(point, sel_y));
+    return CGPointMake(x, y);
 }
 
 /*
@@ -50,36 +42,42 @@ rb_mouse_unwrap_point(VALUE point)
  */
 static
 VALUE
-rb_mouse_current_position(VALUE self)
+rb_mouse_current_position(UNUSED const VALUE self)
 {
-  return CURRENT_POSITION;
+    return CURRENT_POSITION;
 }
 
 /*
  * Move the mouse cursor to the given co-ordinates
  *
- * @param point [CGPoint,Array(Number,Number),#to_point]
- * @param duration [Number] animation time, in seconds (__optional__)
- * @return [CGPoint]
+ * The default duration is 0.2 seconds.
+ *
+ * @overload move_to(point)
+ *   @param point [CGPoint,Array(Number,Number),#to_point]
+ *   @return [CGPoint]
+ * @overload move_to(point, duration)
+ *   @param point [CGPoint,Array(Number,Number),#to_point]
+ *   @param duration [Number] animation time, in seconds
+ *   @return [CGPoint]
  */
 static
 VALUE
-rb_mouse_move_to(int argc, VALUE *argv, VALUE self)
+rb_mouse_move_to(const int argc,
+                 VALUE* const argv,
+                 UNUSED const VALUE self)
 {
-  switch (argc)
-    {
+    switch (argc) {
     case 0:
-      rb_raise(rb_eArgError, "move_to requires at least a one arg");
-      break;
+        rb_raise(rb_eArgError, "move_to requires at least a one arg");
     case 1:
-      mouse_move_to(rb_mouse_unwrap_point(argv[0]));
-      break;
+        mouse_move_to(rb_mouse_unwrap_point(argv[0]));
+        break;
     case 2:
     default:
-      mouse_move_to2(rb_mouse_unwrap_point(argv[0]), NUM2DBL(argv[1]));
+        mouse_move_to2(rb_mouse_unwrap_point(argv[0]), NUM2DBL(argv[1]));
     }
 
-  return CURRENT_POSITION;
+    return CURRENT_POSITION;
 }
 
 /*
@@ -90,71 +88,83 @@ rb_mouse_move_to(int argc, VALUE *argv, VALUE self)
  */
 static
 VALUE
-rb_mouse_drag_to(int argc, VALUE *argv, VALUE self)
+rb_mouse_drag_to(const int argc,
+                 VALUE* const argv,
+                 UNUSED const VALUE self)
 {
-  switch (argc)
-    {
+    switch (argc) {
     case 0:
-      rb_raise(rb_eArgError, "drag_to requires at least a one arg");
-      break;
+        rb_raise(rb_eArgError, "drag_to requires at least a one arg");
     case 1:
-      mouse_drag_to(rb_mouse_unwrap_point(argv[0]));
-      break;
+        mouse_drag_to(rb_mouse_unwrap_point(argv[0]));
+        break;
     case 2:
     default:
-      mouse_drag_to2(rb_mouse_unwrap_point(argv[0]), NUM2DBL(argv[1]));
+        mouse_drag_to2(rb_mouse_unwrap_point(argv[0]), NUM2DBL(argv[1]));
     }
 
-  return CURRENT_POSITION;
+    return CURRENT_POSITION;
 }
 
 /*
  * @note Scrolling by `:pixel` may not actually be by real pixels, but instead
- *       correspond to Cocoa co-ords (I don't have a retina display, so I haven't
- *       checked it out yet).
+ *       correspond to Cocoa co-ords (I don't have a retina display, so I
+ *       haven't checked it out yet).
  *
  * Generate `amount` scroll events at the current cursor position
  *
- * Returns number of lines scrolled. A positive `amount` will scroll up
- * and a negative `amount` will scroll down.
- *
- * An animation duration can also be specified.
- *
- * @param amount [Number]
- * @param units [Symbol] `:pixel` or `:line` (_default_: `:line` ) (__optional__)
- * @param duration [Float] (_default_: `0.2`) (__optional__)
- * @return [Number]
+ * Returns number of lines/pixels scrolled, default `units` are by `line`.
+ * A positive `amount` will scroll up and a negative `amount` will scroll down.
+ *
+ * An animation duration can also be specified, which defaults to 0.2 seconds.
+ *
+ * @overload scroll(amount)
+ *   @param amount [Number]
+ *   @return [Number]
+ * @overload scroll(amount, units)
+ *   @param amount [Number]
+ *   @param units [Symbol] `:pixel` or `:line`
+ *   @return [Number]
+ * @overload scroll(amount, units, duration)
+ *   @param amount [Number]
+ *   @param units [Symbol] `:pixel` or `:line`
+ *   @param duration [Number] animation time, in seconds
+ *   @return [Number]
  */
 static
 VALUE
-rb_mouse_scroll(int argc, VALUE *argv, VALUE self)
+rb_mouse_scroll(const int argc, VALUE* const argv, UNUSED const VALUE self)
 {
-  if (argc == 0 || argc > 3)
-    rb_raise(rb_eArgError, "scroll requires 1..3 arguments, you gave %d", argc);
-
-  int amt = NUM2INT(argv[0]);
-
-  if (argc == 1) {
-    mouse_scroll(amt);
-
-  } else {
-    VALUE             input_units = argv[1];
-    CGScrollEventUnit units;
-
-    if (input_units == sym_pixel)
-      units = kCGScrollEventUnitPixel;
-    else if (input_units == sym_line)
-      units = kCGScrollEventUnitLine;
-    else
-      rb_raise(rb_eArgError, "unknown units `%s'", rb_id2name(input_units));
-
-    if (argc == 2)
-      mouse_scroll2(amt, units);
-    else
-      mouse_scroll3(amt, units, NUM2DBL(argv[2]));
-  }
+    if (argc == 0 || argc > 3)
+        rb_raise(rb_eArgError,
+                 "scroll requires 1..3 arguments, you gave %d",
+                 argc);
+
+    const int amt = NUM2INT(argv[0]);
+
+    if (argc == 1) {
+        mouse_scroll(amt);
+
+    } else {
+        const VALUE input_units = argv[1];
+        CGScrollEventUnit units;
+
+        if (input_units == sym_pixel)
+            units = kCGScrollEventUnitPixel;
+        else if (input_units == sym_line)
+            units = kCGScrollEventUnitLine;
+        else
+            rb_raise(rb_eArgError,
+                     "unknown units `%s'",
+                     rb_id2name(input_units));
+
+        if (argc == 2)
+            mouse_scroll2(amt, units);
+        else
+            mouse_scroll3(amt, units, NUM2DBL(argv[2]));
+    }
 
-  return argv[0];
+    return argv[0];
 }
 
 /*
@@ -164,46 +174,60 @@ rb_mouse_scroll(int argc, VALUE *argv, VALUE self)
  *
  * Generate `amount` of horizontal scroll events at the current cursor position
  *
- * Returns number of lines scrolled. A positive `amount` will scroll left
- * and a negative `amount` will scroll right.
- *
- * An animation duration can also be specified.
- *
- * @param amount [Number]
- * @param units [Symbol] `:pixel` or `:line` (_default_: `:line` ) (__optional__)
- * @param duration [Float] (_default_: `0.2`) (__optional__)
- * @return [Number]
+ * Returns number of lines/pixels scrolled, default `units` are by `line`.
+ * A positive `amount` will scroll up and a negative `amount` will scroll down.
+ *
+ * An animation duration can also be specified, which defaults to 0.2 seconds.
+ *
+ * @overload horizontal_scroll(amount)
+ *   @param amount [Number]
+ *   @return [Number]
+ * @overload horizontal_scroll(amount, units)
+ *   @param amount [Number]
+ *   @param units [Symbol] `:pixel` or `:line`
+ *   @return [Number]
+ * @overload horizontal_scroll(amount, units, duration)
+ *   @param amount [Number]
+ *   @param units [Symbol] `:pixel` or `:line`
+ *   @param duration [Number] animation time, in seconds
+ *   @return [Number]
  */
 static
 VALUE
-rb_mouse_horizontal_scroll(int argc, VALUE *argv, VALUE self)
+rb_mouse_horizontal_scroll(const int argc,
+                           VALUE* const argv,
+                           UNUSED const VALUE self)
 {
-  if (argc == 0 || argc > 3)
-    rb_raise(rb_eArgError, "scroll requires 1..3 arguments, you gave %d", argc);
-
-  int amt = NUM2INT(argv[0]);
-
-  if (argc == 1) {
-    mouse_horizontal_scroll(amt);
-
-  } else {
-    VALUE             input_units = argv[1];
-    CGScrollEventUnit units;
-
-    if (input_units == sym_pixel)
-      units = kCGScrollEventUnitPixel;
-    else if (input_units == sym_line)
-      units = kCGScrollEventUnitLine;
-    else
-      rb_raise(rb_eArgError, "unknown units `%s'", rb_id2name(input_units));
-
-    if (argc == 2)
-      mouse_horizontal_scroll2(amt, units);
-    else
-      mouse_horizontal_scroll3(amt, units, NUM2DBL(argv[2]));
-  }
+    if (argc == 0 || argc > 3)
+        rb_raise(rb_eArgError,
+                 "scroll requires 1..3 arguments, you gave %d",
+                 argc);
+
+    const int amt = NUM2INT(argv[0]);
+
+    if (argc == 1) {
+        mouse_horizontal_scroll(amt);
+
+    } else {
+        const VALUE input_units = argv[1];
+        CGScrollEventUnit units;
+
+        if (input_units == sym_pixel)
+            units = kCGScrollEventUnitPixel;
+        else if (input_units == sym_line)
+            units = kCGScrollEventUnitLine;
+        else
+            rb_raise(rb_eArgError,
+                     "unknown units `%s'",
+                     rb_id2name(input_units));
+
+        if (argc == 2)
+            mouse_horizontal_scroll2(amt, units);
+        else
+            mouse_horizontal_scroll3(amt, units, NUM2DBL(argv[2]));
+    }
 
-  return argv[0];
+    return argv[0];
 }
 
 /*
@@ -213,26 +237,31 @@ rb_mouse_horizontal_scroll(int argc, VALUE *argv, VALUE self)
  * to inject some behaviour between the down and up click events.
  *
  * You can optionally specify a point to click; the mouse cursor will
- * instantly jump to the given point.
- *
- * @param point [CGPoint] (_default_: {#current_position}) (__optional__)
- * @return [CGPoint]
+ * instantly jump to the given point; otherwise the click event happens
+ * at the current cursor position.
+ *
+ * @overload click_down()
+ *   @return [CGPoint]
+ * @overload click_down(point)
+ *   @param point [CGPoint]
+ *   @return [CGPoint]
  */
 static
 VALUE
-rb_mouse_click_down(int argc, VALUE *argv, VALUE self)
+rb_mouse_click_down(const int argc,
+                    VALUE* const argv,
+                    UNUSED const VALUE self)
 {
-  switch (argc)
-    {
+    switch (argc) {
     case 0:
-      mouse_click_down();
-      break;
+        mouse_click_down();
+        break;
     case 1:
     default:
-      mouse_click_down2(rb_mouse_unwrap_point(argv[0]));
+        mouse_click_down2(rb_mouse_unwrap_point(argv[0]));
     }
 
-  return CURRENT_POSITION;
+    return CURRENT_POSITION;
 }
 
 /*
@@ -242,52 +271,58 @@ rb_mouse_click_down(int argc, VALUE *argv, VALUE self)
  * to inject some behaviour between the down and up click events.
  *
  * You can optionally specify a point to click; the mouse cursor will
- * instantly jump to the given point.
- *
- * @param point [CGPoint] (_default_: {#current_position}) (__optional__)
- * @return [CGPoint]
+ * instantly jump to the given point; otherwise the click event happens
+ * at the current cursor position.
+ *
+ * @overload click_up()
+ *   @return [CGPoint]
+ * @overload click_up(point)
+ *   @param point [CGPoint]
+ *   @return [CGPoint]
  */
 static
 VALUE
-rb_mouse_click_up(int argc, VALUE *argv, VALUE self)
+rb_mouse_click_up(const int argc, VALUE* const argv, UNUSED const VALUE self)
 {
-  switch (argc)
-    {
+    switch (argc) {
     case 0:
-      mouse_click_up();
-      break;
+        mouse_click_up();
+        break;
     case 1:
     default:
-      mouse_click_up(rb_mouse_unwrap_point(argv[0]));
+        mouse_click_up2(rb_mouse_unwrap_point(argv[0]));
     }
 
-  return CURRENT_POSITION;
+    return CURRENT_POSITION;
 }
 
 /*
  * Generate a regular click event (both up and down events)
  *
  * You can optionally specify a point to click; the mouse cursor will
- * instantly jump to the given point.
- *
- * @param point [CGPoint] (_default_: {#current_position}) (__optional__)
- * @return [CGPoint]
+ * instantly jump to the given point; otherwise the click event happens
+ * at the current cursor position.
+ *
+ * @overload click()
+ *   @return [CGPoint]
+ * @overload click()
+ *   @param point [CGPoint]
+ *   @return [CGPoint]
  */
 static
 VALUE
-rb_mouse_click(int argc, VALUE *argv, VALUE self)
+rb_mouse_click(const int argc, VALUE* const argv, UNUSED const VALUE self)
 {
-  switch (argc)
-    {
+    switch (argc) {
     case 0:
-      mouse_click();
-      break;
+        mouse_click();
+        break;
     case 1:
     default:
-      mouse_click2(rb_mouse_unwrap_point(argv[0]));
+        mouse_click2(rb_mouse_unwrap_point(argv[0]));
     }
 
-  return CURRENT_POSITION;
+    return CURRENT_POSITION;
 }
 
 /*
@@ -298,26 +333,31 @@ rb_mouse_click(int argc, VALUE *argv, VALUE self)
  * events.
  *
  * You can optionally specify a point to click; the mouse cursor will
- * instantly jump to the given point.
- *
- * @param point [CGPoint] (_default_: {#current_position}) (__optional__)
- * @return [CGPoint]
+ * instantly jump to the given point; otherwise the click event happens
+ * at the current cursor position.
+ *
+ * @overload secondary_click_down()
+ *   @return [CGPoint]
+ * @overload secondary_click_down(point)
+ *   @param point [CGPoint]
+ *   @return [CGPoint]
  */
 static
 VALUE
-rb_mouse_secondary_click_down(int argc, VALUE* argv, VALUE self)
+rb_mouse_secondary_click_down(const int argc,
+                              VALUE* const argv,
+                              UNUSED const VALUE self)
 {
-  switch (argc)
-    {
+    switch (argc) {
     case 0:
-      mouse_secondary_click_down();
-      break;
+        mouse_secondary_click_down();
+        break;
     case 1:
     default:
-      mouse_secondary_click_down2(rb_mouse_unwrap_point(argv[0]));
+        mouse_secondary_click_down2(rb_mouse_unwrap_point(argv[0]));
     }
 
-  return CURRENT_POSITION;
+    return CURRENT_POSITION;
 }
 
 /*
@@ -327,26 +367,31 @@ rb_mouse_secondary_click_down(int argc, VALUE* argv, VALUE self)
  * you want to inject some behaviour between the down and up click events.
  *
  * You can optionally specify a point to click; the mouse cursor will
- * instantly jump to the given point.
- *
- * @param point [CGPoint] (_default_: {#current_position}) (__optional__)
- * @return [CGPoint]
+ * instantly jump to the given point; otherwise the click event happens
+ * at the current cursor position.
+ *
+ * @overload secondary_click_up()
+ *   @return [CGPoint]
+ * @overload secondary_click_up(point)
+ *   @param point [CGPoint]
+ *   @return [CGPoint]
  */
 static
 VALUE
-rb_mouse_secondary_click_up(int argc, VALUE* argv, VALUE self)
+rb_mouse_secondary_click_up(const int argc,
+                            VALUE* const argv,
+                            UNUSED const VALUE self)
 {
-  switch (argc)
-    {
+    switch (argc) {
     case 0:
-      mouse_secondary_click_up();
-      break;
+        mouse_secondary_click_up();
+        break;
     case 1:
     default:
-      mouse_secondary_click_up2(rb_mouse_unwrap_point(argv[0]));
+        mouse_secondary_click_up2(rb_mouse_unwrap_point(argv[0]));
     }
 
-  return CURRENT_POSITION;
+    return CURRENT_POSITION;
 }
 
 /*
@@ -355,26 +400,31 @@ rb_mouse_secondary_click_up(int argc, VALUE* argv, VALUE self)
  * Secondary click is often referred to as "right click".
  *
  * You can optionally specify a point to click; the mouse cursor will
- * instantly jump to the given point.
- *
- * @param point [CGPoint] (_default_: {#current_position}) (__optional__)
- * @return [CGPoint]
+ * instantly jump to the given point; otherwise the click event happens
+ * at the current cursor position.
+ *
+ * @overload secondary_click()
+ *   @return [CGPoint]
+ * @overload secondary_click(point)
+ *   @param point [CGPoint]
+ *   @return [CGPoint]
  */
 static
 VALUE
-rb_mouse_secondary_click(int argc, VALUE *argv, VALUE self)
+rb_mouse_secondary_click(const int argc,
+                         VALUE* const argv,
+                         UNUSED const VALUE self)
 {
-  switch (argc)
-    {
+    switch (argc) {
     case 0:
-      mouse_secondary_click();
-      break;
+        mouse_secondary_click();
+        break;
     case 1:
     default:
-      mouse_secondary_click2(rb_mouse_unwrap_point(argv[0]));
+        mouse_secondary_click2(rb_mouse_unwrap_point(argv[0]));
     }
 
-  return CURRENT_POSITION;
+    return CURRENT_POSITION;
 }
 
 /*
@@ -385,31 +435,37 @@ rb_mouse_secondary_click(int argc, VALUE *argv, VALUE self)
  * events.
  *
  * You can optionally specify a point to click; the mouse cursor will
- * instantly jump to the given point.
- *
- * @param point [CGPoint] (_default_: {#current_position}) (__optional__)
- * @return [CGPoint]
+ * instantly jump to the given point; otherwise the click event happens
+ * at the current cursor position.
+ *
+ * @overload arbitrary_click_down()
+ *   @return [CGPoint]
+ * @overload arbitrary_click_down(point)
+ *   @param point [CGPoint]
+ *   @return [CGPoint]
  */
 static
 VALUE
-rb_mouse_arbitrary_click_down(int argc, VALUE* argv, VALUE self)
+rb_mouse_arbitrary_click_down(const int argc,
+                              VALUE* const argv,
+                              UNUSED const VALUE self)
 {
-  if (argc == 0)
-    rb_raise(rb_eArgError, "arbitrary_click_down requires at least one arg");
+    if (argc == 0)
+        rb_raise(rb_eArgError,
+                 "arbitrary_click_down requires at least one arg");
 
-  uint_t button = NUM2INT(argv[0]);
+    const uint_t button = NUM2UINT(argv[0]);
 
-  switch (argc)
-    {
+    switch (argc) {
     case 1:
-      mouse_arbitrary_click_down(button);
-      break;
+        mouse_arbitrary_click_down(button);
+        break;
     case 2:
     default:
-      mouse_arbitrary_click_down2(button, rb_mouse_unwrap_point(argv[1]));
+        mouse_arbitrary_click_down2(button, rb_mouse_unwrap_point(argv[1]));
     }
 
-  return CURRENT_POSITION;
+    return CURRENT_POSITION;
 }
 
 /*
@@ -419,31 +475,37 @@ rb_mouse_arbitrary_click_down(int argc, VALUE* argv, VALUE self)
  * you want to inject some behaviour between the down and up click events.
  *
  * You can optionally specify a point to click; the mouse cursor will
- * instantly jump to the given point.
- *
- * @param point [CGPoint] (_default_: {#current_position}) (__optional__)
- * @return [CGPoint]
+ * instantly jump to the given point; otherwise the click event happens
+ * at the current cursor position.
+ *
+ * @overload arbitrary_click_up()
+ *   @return [CGPoint]
+ * @overload arbitrary_click_up(point)
+ *   @param point [CGPoint]
+ *   @return [CGPoint]
  */
 static
 VALUE
-rb_mouse_arbitrary_click_up(int argc, VALUE* argv, VALUE self)
+rb_mouse_arbitrary_click_up(const int argc,
+                            VALUE* const argv,
+                            UNUSED const VALUE self)
 {
-  if (argc == 0)
-    rb_raise(rb_eArgError, "arbitrary_click_up requires at least one arg");
+    if (argc == 0)
+        rb_raise(rb_eArgError,
+                 "arbitrary_click_up requires at least one arg");
 
-  uint_t button = NUM2INT(argv[0]);
+    const uint_t button = NUM2UINT(argv[0]);
 
-  switch (argc)
-    {
+    switch (argc) {
     case 1:
-      mouse_arbitrary_click_up(button);
-      break;
+        mouse_arbitrary_click_up(button);
+        break;
     case 2:
     default:
-      mouse_arbitrary_click_up2(button, rb_mouse_unwrap_point(argv[1]));
+        mouse_arbitrary_click_up2(button, rb_mouse_unwrap_point(argv[1]));
     }
 
-  return CURRENT_POSITION;
+    return CURRENT_POSITION;
 }
 
 /*
@@ -461,34 +523,40 @@ rb_mouse_arbitrary_click_up(int argc, VALUE* argv, VALUE self)
  * documentation for the most up to date list.
  *
  * You can optionally specify a point to click; the mouse cursor will
- * instantly jump to the given point.
- *
- * @param button [Number,#to_i]
- * @param point [CGPoint] (_default_: {#current_position}) (__optional__)
- * @return [CGPoint]
+ * instantly jump to the given point; otherwise the click event happens
+ * at the current cursor position.
+ *
+ * @overload arbitrary_click(button)
+ *   @param button [Number,#to_i]
+ *   @return [CGPoint]
+ * @overload arbitrary_click(button, point)
+ *   @param button [Number,#to_i]
+ *   @param point [CGPoint]
+ *   @return [CGPoint]
  */
 static
 VALUE
-rb_mouse_arbitrary_click(int argc, VALUE *argv, VALUE self)
+rb_mouse_arbitrary_click(const int argc,
+                         VALUE* const argv,
+                         UNUSED const VALUE self)
 {
-  if (argc == 0) {
-    rb_raise(rb_eArgError, "arbitrary_click requires at least one arg");
-    return Qnil;
-  }
+    if (argc == 0) {
+        rb_raise(rb_eArgError, "arbitrary_click requires at least one arg");
+        return Qnil;
+    }
 
-  uint_t button = NUM2INT(argv[0]);
+    const uint_t button = NUM2UINT(argv[0]);
 
-  switch (argc)
-    {
+    switch (argc) {
     case 1:
-      mouse_arbitrary_click(button);
-      break;
+        mouse_arbitrary_click(button);
+        break;
     case 2:
     default:
-      mouse_arbitrary_click2(button, rb_mouse_unwrap_point(argv[1]));
+        mouse_arbitrary_click2(button, rb_mouse_unwrap_point(argv[1]));
     }
 
-  return CURRENT_POSITION;
+    return CURRENT_POSITION;
 }
 
 /*
@@ -497,26 +565,31 @@ rb_mouse_arbitrary_click(int argc, VALUE *argv, VALUE self)
  * It doesn't matter if you don't have a middle mouse button.
  *
  * You can optionally specify a point to click; the mouse cursor will
- * instantly jump to the given point.
- *
- * @param point [CGPoint] (_default_: {#current_position}) (__optional__)
- * @return [CGPoint]
+ * instantly jump to the given point; otherwise the click event happens
+ * at the current cursor position.
+ *
+ * @overload middle_click()
+ *   @return [CGPoint]
+ * @overload middle_click(point)
+ *   @param point [CGPoint]
+ *   @return [CGPoint]
  */
 static
 VALUE
-rb_mouse_middle_click(int argc, VALUE *argv, VALUE self)
+rb_mouse_middle_click(const int argc,
+                      VALUE* const argv,
+                      UNUSED const VALUE self)
 {
-  switch (argc)
-    {
+    switch (argc) {
     case 0:
-      mouse_middle_click();
-      break;
+        mouse_middle_click();
+        break;
     case 1:
     default:
-      mouse_middle_click(rb_mouse_unwrap_point(argv[0]));
+        mouse_middle_click2(rb_mouse_unwrap_point(argv[0]));
     }
 
-  return CURRENT_POSITION;
+    return CURRENT_POSITION;
 }
 
 /*
@@ -526,36 +599,42 @@ rb_mouse_middle_click(int argc, VALUE *argv, VALUE self)
  * a single event with the given number of clicks.
  *
  * You can optionally specify a point to click; the mouse cursor will
- * instantly jump to the given point.
- *
- * @param num_clicks [Number,#to_i]
- * @param point [CGPoint] (_default_: {#current_position}) (__optional__)
- * @return [CGPoint]
+ * instantly jump to the given point; otherwise the click event happens
+ * at the current cursor position.
+ *
+ * @overload multi_click(num_clicks)
+ *   @param num_clicks [Number,#to_i]
+ *   @return [CGPoint]
+ * @overload multi_click(num_clicks, point)
+ *   @param num_clicks [Number,#to_i]
+ *   @param point [CGPoint]
+ *   @return [CGPoint]
  */
 static
 VALUE
-rb_mouse_multi_click(int argc, VALUE *argv, VALUE self)
+rb_mouse_multi_click(const int argc,
+                     VALUE* const argv,
+                     UNUSED const VALUE self)
 {
 
-  if (argc == 0) {
-    rb_raise(rb_eArgError, "multi_click requires at least one arg");
-    return Qnil;
-  }
+    if (argc == 0) {
+        rb_raise(rb_eArgError, "multi_click requires at least one arg");
+        return Qnil;
+    }
 
-  // TODO: there has got to be a more idiomatic way to do this coercion
-  size_t num_clicks = NUM2SIZET(argv[0]);
+    // TODO: there has got to be a more idiomatic way to do this coercion
+    const size_t num_clicks = NUM2SIZET(argv[0]);
 
-  switch (argc)
-    {
+    switch (argc) {
     case 1:
-      mouse_multi_click(num_clicks);
-      break;
+        mouse_multi_click(num_clicks);
+        break;
     case 2:
     default:
-      mouse_multi_click2(num_clicks, rb_mouse_unwrap_point(argv[1]));
+        mouse_multi_click2(num_clicks, rb_mouse_unwrap_point(argv[1]));
     }
 
-  return CURRENT_POSITION;
+    return CURRENT_POSITION;
 }
 
 /*
@@ -566,26 +645,31 @@ rb_mouse_multi_click(int argc, VALUE *argv, VALUE self)
  * how a human would have to generate a double click event.
  *
  * You can optionally specify a point to click; the mouse cursor will
- * instantly jump to the given point.
- *
- * @param point [CGPoint] (_default_: {#current_position}) (__optional__)
- * @return [CGPoint]
+ * instantly jump to the given point; otherwise the click event happens
+ * at the current cursor position.
+ *
+ * @overload double_click()
+ *   @return [CGPoint]
+ * @overload double_click(point)
+ *   @param point [CGPoint]
+ *   @return [CGPoint]
  */
 static
 VALUE
-rb_mouse_double_click(int argc, VALUE *argv, VALUE self)
+rb_mouse_double_click(const int argc,
+                      VALUE* const argv,
+                      UNUSED const VALUE self)
 {
-  switch (argc)
-    {
+    switch (argc) {
     case 0:
-      mouse_double_click();
-      break;
+        mouse_double_click();
+        break;
     case 1:
     default:
-      mouse_double_click2(rb_mouse_unwrap_point(argv[0]));
+        mouse_double_click2(rb_mouse_unwrap_point(argv[0]));
     }
 
-  return CURRENT_POSITION;
+    return CURRENT_POSITION;
 }
 
 /*
@@ -597,26 +681,31 @@ rb_mouse_double_click(int argc, VALUE *argv, VALUE self)
  * triple click event.
  *
  * You can optionally specify a point to click; the mouse cursor will
- * instantly jump to the given point.
- *
- * @param point [CGPoint] (_default_: {#current_position}) (__optional__)
- * @return [CGPoint]
+ * instantly jump to the given point; otherwise the click event happens
+ * at the current cursor position.
+ *
+ * @overload triple_click()
+ *   @return [CGPoint]
+ * @overload triple_click(point)
+ *   @param point [CGPoint]
+ *   @return [CGPoint]
  */
 static
 VALUE
-rb_mouse_triple_click(int argc, VALUE *argv, VALUE self)
+rb_mouse_triple_click(const int argc,
+                      VALUE* const argv,
+                      UNUSED const VALUE self)
 {
-  switch (argc)
-    {
+    switch (argc) {
     case 0:
-      mouse_triple_click();
-      break;
+        mouse_triple_click();
+        break;
     case 1:
     default:
-      mouse_triple_click2(rb_mouse_unwrap_point(argv[0]));
+        mouse_triple_click2(rb_mouse_unwrap_point(argv[0]));
     }
 
-  return CURRENT_POSITION;
+    return CURRENT_POSITION;
 }
 
 
@@ -625,27 +714,32 @@ rb_mouse_triple_click(int argc, VALUE *argv, VALUE self)
 /*
  * Perform a smart magnify (double tap on trackpad)
  *
- * You can optionally specify the point on the screen where to perform
- * the smart magnification.
- *
- * @param point [CGPoint] (_default_: {#current_position}) (__optional__)
- * @return [CGPoint]
+ * You can optionally specify a point to click; the mouse cursor will
+ * instantly jump to the given point; otherwise the click event happens
+ * at the current cursor position.
+ *
+ * @overload smart_magnify()
+ *   @return [CGPoint]
+ * @overload smart_magnify(point)
+ *   @param point [CGPoint]
+ *   @return [CGPoint]
  */
 static
 VALUE
-rb_mouse_smart_magnify(int argc, VALUE* argv, VALUE self)
+rb_mouse_smart_magnify(const int argc,
+                       VALUE* const argv,
+                       UNUSED const VALUE self)
 {
-  switch (argc)
-    {
+    switch (argc) {
     case 0:
-      mouse_smart_magnify();
-      break;
+        mouse_smart_magnify();
+        break;
     case 1:
     default:
-      mouse_smart_magnify2(rb_mouse_unwrap_point(argv[0]));
+        mouse_smart_magnify2(rb_mouse_unwrap_point(argv[0]));
     }
 
-  return CURRENT_POSITION;
+    return CURRENT_POSITION;
 }
 
 /*
@@ -653,52 +747,55 @@ rb_mouse_smart_magnify(int argc, VALUE* argv, VALUE self)
  *
  * You can optionally specify a point on screen for the mouse
  * pointer to be moved to before the gesture begins. The movement will
- * be instantaneous.
- *
- * You can also optionally specify the duration of the swipe event.
- *
- * @param direction [Symbol]
- * @param point [CGPoint] (_default_: {#current_position}) (__optional__)
- * @param duration [Float] (_default_: `0.2`) (__optional__)
- * @return [CGPoint]
+ * be instantaneous; otherwise the click event happens
+ * at the current cursor position.
+ *
+ * You can also optionally specify the duration of the swipe event;
+ * the default `duration` is 0.2 seconds.
+ *
+ * @overload swipe(direction)
+ *   @param direction [Symbol]
+ *   @return [CGPoint]
+ * @overload swipe(direction, point)
+ *   @param direction [Symbol]
+ *   @param point [CGPoint]
+ *   @return [CGPoint]
+ * @overload swipe(direction, point, duration)
+ *   @param direction [Symbol]
+ *   @param point [CGPoint]
+ *   @param duration [Float]
+ *   @return [CGPoint]
  */
 static
 VALUE
-rb_mouse_swipe(int argc, VALUE* argv, VALUE self)
+rb_mouse_swipe(const int argc, VALUE* const argv, UNUSED const VALUE self)
 {
-  if (!argc)
-    rb_raise(rb_eArgError, "wrong number of arguments (0 for 1+)");
-
-  CGSwipeDirection direction;
-  VALUE direction_input = argv[0];
-  if (direction_input == sym_up)
-    direction = kCGSwipeDirectionUp;
-  else if (direction_input == sym_down)
-    direction = kCGSwipeDirectionDown;
-  else if (direction_input == sym_left)
-    direction = kCGSwipeDirectionLeft;
-  else if (direction_input == sym_right)
-    direction = kCGSwipeDirectionRight;
-  else
-    rb_raise(
-	     rb_eArgError,
-	     "invalid swipe direction `%s'",
-	     rb_id2name(SYM2ID(direction_input))
-	     );
-
-  if (argc == 1) {
-    mouse_swipe(direction);
-    return CURRENT_POSITION;
-  }
+    if (!argc)
+        rb_raise(rb_eArgError, "wrong number of arguments (0 for 1+)");
+
+    const VALUE direction_input = argv[0];
+    CGSwipeDirection direction;
+    if (direction_input == sym_up)
+        direction = kCGSwipeDirectionUp;
+    else if (direction_input == sym_down)
+        direction = kCGSwipeDirectionDown;
+    else if (direction_input == sym_left)
+        direction = kCGSwipeDirectionLeft;
+    else if (direction_input == sym_right)
+        direction = kCGSwipeDirectionRight;
+    else
+        rb_raise(rb_eArgError,
+                 "invalid swipe direction `%s'",
+                 rb_id2name(SYM2ID(direction_input)));
 
-  CGPoint point = rb_mouse_unwrap_point(argv[1]);
+    if (argc == 1) {
+      mouse_swipe(direction);
+      return CURRENT_POSITION;
+    }
 
-  if (argc == 2)
+    const CGPoint point = rb_mouse_unwrap_point(argv[1]);
     mouse_swipe2(direction, point);
-  else
-    mouse_swipe3(direction, point, NUM2DBL(argv[1]));
-
-  return CURRENT_POSITION;
+    return CURRENT_POSITION;
 }
 
 /*
@@ -714,61 +811,72 @@ rb_mouse_swipe(int argc, VALUE* argv, VALUE self)
  *
  * Magnification is a relative magnification setting. A zoom value of
  * `1.0` means `1.0` more than the current zoom level. `2.0` would be
- * `2.0` levels higher than the current zoom.
+ * `2.0` levels higher than the current zoom. Default is `1.0`.
  *
  * You can also optionally specify a point on screen for the mouse
  * pointer to be moved to before the gesture begins. The movement will
- * be instantaneous.
- *
- * An animation duration can also be specified.
- *
- * @param direction [Symbol]
- * @param magnification [Float] (_default_: `1.0`) (__optional__)
- * @param point [CGPoint] (_default_: {#current_position}) (__optional__)
- * @param duration [Float] (_default_: `0.2`) (__optional__)
- * @return [CGPoint]
+ * be instantaneous. Default `point` is {#current_position}.
+ *
+ * An animation duration can also be specified. The default is 0.2 seconds.
+ *
+ * @overload pinch(direction)
+ *   @param direction [Symbol]
+ *   @return [CGPoint]
+ * @overload pinch(direction, magnification)
+ *   @param direction [Symbol]
+ *   @param magnification [Float]
+ *   @return [CGPoint]
+ * @overload pinch(direction, magnification, point)
+ *   @param direction [Symbol]
+ *   @param magnification [Float]
+ *   @param point [CGPoint]
+ *   @return [CGPoint]
+ * @overload pinch(direction, magnification, point, duration)
+ *   @param direction [Symbol]
+ *   @param magnification [Float]
+ *   @param point [CGPoint]
+ *   @param duration [Float]
+ *   @return [CGPoint]
  */
 static
 VALUE
-rb_mouse_pinch(int argc, VALUE* argv, VALUE self)
+rb_mouse_pinch(const int argc, VALUE* const argv, UNUSED const VALUE self)
 {
-  if (!argc)
-    rb_raise(rb_eArgError, "wrong number of arguments (%d for 1+)", argc);
-
-  VALUE            input_direction = argv[0];
-  CGPinchDirection       direction = kCGPinchNone;
-
-  if (input_direction == sym_expand || input_direction == sym_zoom)
-    direction = kCGPinchExpand;
-  else if (input_direction == sym_contract || input_direction == sym_unzoom)
-    direction = kCGPinchContract;
-  else
-    rb_raise(
-	     rb_eArgError,
-	     "invalid pinch direction `%s'",
-	     rb_id2name(SYM2ID(input_direction))
-	     );
-
-  if (argc == 1) {
-    mouse_pinch(direction);
-    return CURRENT_POSITION;
-  }
+    if (!argc)
+        rb_raise(rb_eArgError, "wrong number of arguments (%d for 1+)", argc);
 
-  double magnification = NUM2DBL(argv[1]);
-  if (argc == 2) {
-    mouse_pinch2(direction, magnification);
-    return CURRENT_POSITION;
-  }
+    const VALUE input_direction = argv[0];
+    CGPinchDirection  direction = kCGPinchNone;
 
-  CGPoint point = rb_mouse_unwrap_point(argv[2]);
-  if (argc == 3) {
-    mouse_pinch3(direction, magnification, point);
-    return CURRENT_POSITION;
-  }
+    if (input_direction == sym_expand || input_direction == sym_zoom)
+        direction = kCGPinchExpand;
+    else if (input_direction == sym_contract || input_direction == sym_unzoom)
+        direction = kCGPinchContract;
+    else
+        rb_raise(rb_eArgError,
+                 "invalid pinch direction `%s'",
+                 rb_id2name(SYM2ID(input_direction)));
+
+    if (argc == 1) {
+        mouse_pinch(direction);
+        return CURRENT_POSITION;
+    }
 
-  double duration = NUM2DBL(argv[3]);
-  mouse_pinch4(direction, magnification, point, duration);
-  return CURRENT_POSITION;
+    const double magnification = NUM2DBL(argv[1]);
+    if (argc == 2) {
+        mouse_pinch2(direction, magnification);
+        return CURRENT_POSITION;
+    }
+
+    const CGPoint point = rb_mouse_unwrap_point(argv[2]);
+    if (argc == 3) {
+        mouse_pinch3(direction, magnification, point);
+        return CURRENT_POSITION;
+    }
+
+    const double duration = NUM2DBL(argv[3]);
+    mouse_pinch4(direction, magnification, point, duration);
+    return CURRENT_POSITION;
 }
 
 /*
@@ -786,142 +894,150 @@ rb_mouse_pinch(int argc, VALUE* argv, VALUE self)
  *
  * You can also optionally specify a point on screen for the mouse
  * pointer to be moved to before the gesture begins. The movement will
- * be instantaneous.
- *
- * An animation duration can also be specified.
- *
- * @param direction [Symbol]
- * @param angle [Float]
- * @param point [CGPoint] (_default_: {#current_position}) (__optional__)
- * @param duration [Float] (_default_: `0.2`) (__optional__)
- * @return [CGPoint]
+ * be instantaneous. Default `point` is {#current_position}.
+ *
+ * An animation duration can also be specified. The default is 0.2 seconds.
+ *
+ * @overload rotate(direction, angle)
+ *   @param direction [Symbol]
+ *   @param angle [Float]
+ *   @return [CGPoint]
+ * @overload rotate(direction, angle, point)
+ *   @param direction [Symbol]
+ *   @param angle [Float]
+ *   @param point [CGPoint]
+ *   @return [CGPoint]
+ * @overload rotate(direction, angle, point, duration)
+ *   @param direction [Symbol]
+ *   @param angle [Float]
+ *   @param point [CGPoint]
+ *   @param duration [Float]
+ *   @return [CGPoint]
  */
 static
 VALUE
-rb_mouse_rotate(int argc, VALUE* argv, VALUE self)
+rb_mouse_rotate(const int argc, VALUE* const argv, UNUSED const VALUE self)
 {
-  if (argc < 2)
-    rb_raise(rb_eArgError, "wrong number of arguments (%d for 2+)", argc);
-
-  CGRotateDirection direction = kCGRotateNone;
-  VALUE             input_dir = argv[0];
-  if (
-      input_dir == sym_cw ||
-      input_dir == sym_clockwise ||
-      input_dir == sym_clock_wise
-      )
-    direction = kCGRotateClockwise;
-  else if (
-      input_dir == sym_ccw ||
-      input_dir == sym_counter_clockwise ||
-      input_dir == sym_counter_clock_wise
-	   )
-    direction = kCGRotateCounterClockwise;
-  else
-    rb_raise(
-	     rb_eArgError,
-	     "invalid rotation direction `%s'",
-	     rb_id2name(SYM2ID(input_dir))
-	     );
-
-  double angle = NUM2DBL(argv[1]);
-
-  if (argc == 2) {
-    mouse_rotate(direction, angle);
-    return CURRENT_POSITION;
-  }
+    if (argc < 2)
+        rb_raise(rb_eArgError, "wrong number of arguments (%d for 2+)", argc);
 
-  CGPoint point = rb_mouse_unwrap_point(argv[2]);
-  if (argc == 3) {
-    mouse_rotate2(direction, angle, point);
-    return CURRENT_POSITION;
-  }
 
-  mouse_rotate3(direction, angle, point, NUM2DBL(argv[3]));
-  return CURRENT_POSITION;
+    const VALUE input_dir = argv[0];
+    CGRotateDirection direction;
+
+    if      (input_dir == sym_cw ||
+             input_dir == sym_clockwise ||
+             input_dir == sym_clock_wise)
+        direction = kCGRotateClockwise;
+
+    else if (input_dir == sym_ccw ||
+             input_dir == sym_counter_clockwise ||
+             input_dir == sym_counter_clock_wise)
+        direction = kCGRotateCounterClockwise;
+    else
+        rb_raise(rb_eArgError,
+                 "invalid rotation direction `%s'",
+                 rb_id2name(SYM2ID(input_dir)));
+
+    const double angle = NUM2DBL(argv[1]);
+
+    if (argc == 2) {
+        mouse_rotate(direction, angle);
+        return CURRENT_POSITION;
+    }
+
+    const CGPoint point = rb_mouse_unwrap_point(argv[2]);
+    if (argc == 3) {
+        mouse_rotate2(direction, angle, point);
+        return CURRENT_POSITION;
+    }
+
+    mouse_rotate3(direction, angle, point, NUM2DBL(argv[3]));
+    return CURRENT_POSITION;
 }
 
 /* @!endgroup */
 
 
+void Init_mouse(void);
+
 void
 Init_mouse()
 {
-  // on either supported Ruby, this should be defined by now
-  rb_cCGPoint = rb_const_get(rb_cObject, rb_intern("CGPoint"));
-
-  sel_x        = rb_intern("x");
-  sel_y        = rb_intern("y");
-  sel_to_point = rb_intern("to_point");
-  sel_new      = rb_intern("new");
-
-  sym_pixel    = ID2SYM(rb_intern("pixel"));
-  sym_line     = ID2SYM(rb_intern("line"));
-
-  sym_up       = ID2SYM(rb_intern("up"));
-  sym_down     = ID2SYM(rb_intern("down"));
-  sym_left     = ID2SYM(rb_intern("left"));
-  sym_right    = ID2SYM(rb_intern("right"));
-
-  sym_zoom     = ID2SYM(rb_intern("zoom"));
-  sym_unzoom   = ID2SYM(rb_intern("unzoom"));
-  sym_expand   = ID2SYM(rb_intern("expand"));
-  sym_contract = ID2SYM(rb_intern("contract"));
-
-  sym_cw                 = ID2SYM(rb_intern("cw"));
-  sym_clockwise          = ID2SYM(rb_intern("clockwise"));
-  sym_clock_wise         = ID2SYM(rb_intern("clock_wise"));
-  sym_ccw                = ID2SYM(rb_intern("ccw"));
-  sym_counter_clockwise  = ID2SYM(rb_intern("counter_clockwise"));
-  sym_counter_clock_wise = ID2SYM(rb_intern("counter_clock_wise"));
-
-
-  /*
-   * Document-module: Mouse
-   *
-   * A module with methods that "tap" into the system input methods.
-   * This is done by wrapping wrapping around the CoreGraphics event
-   * taps API provided by OS X.
-   *
-   * The module provides a simple Ruby interface to performing mouse
-   * interactions such as moving and clicking.
-   *
-   * This module can be used in a stand alone fashion or you can mix
-   * it into another class.
-   *
-   * [Reference](http://developer.apple.com/library/mac/#documentation/Carbon/Reference/QuartzEventServicesRef/Reference/reference.html)
-   */
-  rb_mMouse = rb_define_module("Mouse");
-
-  rb_extend_object(rb_mMouse, rb_mMouse);
-
-  rb_define_method(rb_mMouse, "current_position",     rb_mouse_current_position,      0);
-  rb_define_method(rb_mMouse, "move_to",              rb_mouse_move_to,              -1);
-  rb_define_method(rb_mMouse, "drag_to",              rb_mouse_drag_to,              -1);
-  rb_define_method(rb_mMouse, "scroll",               rb_mouse_scroll,               -1);
-  rb_define_method(rb_mMouse, "horizontal_scroll",    rb_mouse_horizontal_scroll,    -1);
-  rb_define_method(rb_mMouse, "click_down",           rb_mouse_click_down,           -1);
-  rb_define_method(rb_mMouse, "click_up",             rb_mouse_click_up,             -1);
-  rb_define_method(rb_mMouse, "click",                rb_mouse_click,                -1);
-  rb_define_method(rb_mMouse, "secondary_click_down", rb_mouse_secondary_click_down, -1);
-  rb_define_method(rb_mMouse, "secondary_click_up",   rb_mouse_secondary_click_up,   -1);
-  rb_define_method(rb_mMouse, "secondary_click",      rb_mouse_secondary_click,      -1);
-  rb_define_method(rb_mMouse, "middle_click",         rb_mouse_middle_click,         -1);
-  rb_define_method(rb_mMouse, "arbitrary_click_down", rb_mouse_arbitrary_click_down, -1);
-  rb_define_method(rb_mMouse, "arbitrary_click_up",   rb_mouse_arbitrary_click_up,   -1);
-  rb_define_method(rb_mMouse, "arbitrary_click",      rb_mouse_arbitrary_click,      -1);
-  rb_define_method(rb_mMouse, "multi_click",          rb_mouse_multi_click,          -1);
-  rb_define_method(rb_mMouse, "double_click",         rb_mouse_double_click,         -1);
-  rb_define_method(rb_mMouse, "triple_click",         rb_mouse_triple_click,         -1);
-
-  rb_define_method(rb_mMouse, "smart_magnify",        rb_mouse_smart_magnify,        -1);
-  rb_define_method(rb_mMouse, "swipe",                rb_mouse_swipe,                -1);
-  rb_define_method(rb_mMouse, "pinch",                rb_mouse_pinch,                -1);
-  rb_define_method(rb_mMouse, "rotate",               rb_mouse_rotate,               -1);
-
-  rb_define_alias(rb_mMouse, "hscroll",               "horizontal_scroll");
-  rb_define_alias(rb_mMouse, "right_click_down",      "secondary_click_down");
-  rb_define_alias(rb_mMouse, "right_click_up",        "secondary_click_up");
-  rb_define_alias(rb_mMouse, "right_click",           "secondary_click");
-  rb_define_alias(rb_mMouse, "two_finger_double_tap", "smart_magnify");
+    // on either supported Ruby, this should be defined by now
+    rb_cCGPoint = rb_const_get(rb_cObject, rb_intern("CGPoint"));
+
+    sel_x        = rb_intern("x");
+    sel_y        = rb_intern("y");
+    sel_to_point = rb_intern("to_point");
+    sel_new      = rb_intern("new");
+
+    sym_pixel    = ID2SYM(rb_intern("pixel"));
+    sym_line     = ID2SYM(rb_intern("line"));
+
+    sym_up       = ID2SYM(rb_intern("up"));
+    sym_down     = ID2SYM(rb_intern("down"));
+    sym_left     = ID2SYM(rb_intern("left"));
+    sym_right    = ID2SYM(rb_intern("right"));
+
+    sym_zoom     = ID2SYM(rb_intern("zoom"));
+    sym_unzoom   = ID2SYM(rb_intern("unzoom"));
+    sym_expand   = ID2SYM(rb_intern("expand"));
+    sym_contract = ID2SYM(rb_intern("contract"));
+
+    sym_cw                 = ID2SYM(rb_intern("cw"));
+    sym_clockwise          = ID2SYM(rb_intern("clockwise"));
+    sym_clock_wise         = ID2SYM(rb_intern("clock_wise"));
+    sym_ccw                = ID2SYM(rb_intern("ccw"));
+    sym_counter_clockwise  = ID2SYM(rb_intern("counter_clockwise"));
+    sym_counter_clock_wise = ID2SYM(rb_intern("counter_clock_wise"));
+
+    /*
+     * Document-module: Mouse
+     *
+     * A module with methods that "tap" into the system input methods.
+     * This is done by wrapping wrapping around the CoreGraphics event
+     * taps API provided by OS X.
+     *
+     * The module provides a simple Ruby interface to performing mouse
+     * interactions such as moving and clicking.
+     *
+     * This module can be used in a stand alone fashion or you can mix
+     * it into another class.
+     *
+     * [Reference](http://developer.apple.com/library/mac/#documentation/Carbon/Reference/QuartzEventServicesRef/Reference/reference.html)
+     */
+    rb_mMouse = rb_define_module("Mouse");
+
+    rb_extend_object(rb_mMouse, rb_mMouse);
+
+    rb_define_method(rb_mMouse, "current_position",     rb_mouse_current_position,      0);
+    rb_define_method(rb_mMouse, "move_to",              rb_mouse_move_to,              -1);
+    rb_define_method(rb_mMouse, "drag_to",              rb_mouse_drag_to,              -1);
+    rb_define_method(rb_mMouse, "scroll",               rb_mouse_scroll,               -1);
+    rb_define_method(rb_mMouse, "horizontal_scroll",    rb_mouse_horizontal_scroll,    -1);
+    rb_define_method(rb_mMouse, "click_down",           rb_mouse_click_down,           -1);
+    rb_define_method(rb_mMouse, "click_up",             rb_mouse_click_up,             -1);
+    rb_define_method(rb_mMouse, "click",                rb_mouse_click,                -1);
+    rb_define_method(rb_mMouse, "secondary_click_down", rb_mouse_secondary_click_down, -1);
+    rb_define_method(rb_mMouse, "secondary_click_up",   rb_mouse_secondary_click_up,   -1);
+    rb_define_method(rb_mMouse, "secondary_click",      rb_mouse_secondary_click,      -1);
+    rb_define_method(rb_mMouse, "middle_click",         rb_mouse_middle_click,         -1);
+    rb_define_method(rb_mMouse, "arbitrary_click_down", rb_mouse_arbitrary_click_down, -1);
+    rb_define_method(rb_mMouse, "arbitrary_click_up",   rb_mouse_arbitrary_click_up,   -1);
+    rb_define_method(rb_mMouse, "arbitrary_click",      rb_mouse_arbitrary_click,      -1);
+    rb_define_method(rb_mMouse, "multi_click",          rb_mouse_multi_click,          -1);
+    rb_define_method(rb_mMouse, "double_click",         rb_mouse_double_click,         -1);
+    rb_define_method(rb_mMouse, "triple_click",         rb_mouse_triple_click,         -1);
+
+    rb_define_method(rb_mMouse, "smart_magnify",        rb_mouse_smart_magnify,        -1);
+    rb_define_method(rb_mMouse, "swipe",                rb_mouse_swipe,                -1);
+    rb_define_method(rb_mMouse, "pinch",                rb_mouse_pinch,                -1);
+    rb_define_method(rb_mMouse, "rotate",               rb_mouse_rotate,               -1);
+
+    rb_define_alias(rb_mMouse, "hscroll",               "horizontal_scroll");
+    rb_define_alias(rb_mMouse, "right_click_down",      "secondary_click_down");
+    rb_define_alias(rb_mMouse, "right_click_up",        "secondary_click_up");
+    rb_define_alias(rb_mMouse, "right_click",           "secondary_click");
+    rb_define_alias(rb_mMouse, "two_finger_double_tap", "smart_magnify");
 }