diff --git a/ext/v8/class_builder.h b/ext/v8/class_builder.h
index 163b88f..c0c7b1e 100644
--- a/ext/v8/class_builder.h
+++ b/ext/v8/class_builder.h
@@ -1,3 +1,4 @@
+// -*- mode: c++ -*-
 #ifndef RR_CLASS_BUILDER
 #define RR_CLASS_BUILDER
 
diff --git a/ext/v8/ref.h b/ext/v8/ref.h
index 6beb7a5..8d4fe79 100644
--- a/ext/v8/ref.h
+++ b/ext/v8/ref.h
@@ -1,33 +1,34 @@
+// -*- mode: c++ -*-
 #ifndef RR_REF
 #define RR_REF
 
 namespace rr {
   /**
-  * A Reference to a V8 managed object
-  *
-  * Uses type coercion to quickly convert from a v8 handle
-  * to a ruby object and back again. Suppose we have a v8 handle
-  * that we want to return to Ruby. We can put it into a Ref:
-  *
-  *     v8::Handle<v8::Object> object = v8::Object::New();
-  *     VALUE val = Ref<v8::Object>(object);
-  *
-  * this will create a `v8::Persistent` handle for the object
-  * so that it will not be garbage collected by v8. It then
-  * stuffs this new persistent handle into a Data_Wrap_Struct
-  * which can then be passed to Ruby code. When this struct
-  * is garbage collected by Ruby, it enqueues the corresponding
-  * v8 handle to be released during v8 gc.
-  *
-  * By the same token, you can use Refs to unwrap a Data_Wrap_Struct
-  * which has been generated in this fashion and call through to
-  * the underlying v8 methods. Suppose we are passed a VALUE `val`
-  * wrapping a v8::Object:
-  *
-  *     Ref<v8::Object> object(val);
-  *     object->Get(v8::String::New("foo"));
-  *
-  */
+   * A Reference to a V8 managed object
+   *
+   * Uses type coercion to quickly convert from a v8 handle
+   * to a ruby object and back again. Suppose we have a v8 handle
+   * that we want to return to Ruby. We can put it into a Ref:
+   *
+   *     v8::Handle<v8::Object> object = v8::Object::New();
+   *     VALUE val = Ref<v8::Object>(object);
+   *
+   * this will create a `v8::Persistent` handle for the object
+   * so that it will not be garbage collected by v8. It then
+   * stuffs this new persistent handle into a Data_Wrap_Struct
+   * which can then be passed to Ruby code. When this struct
+   * is garbage collected by Ruby, it enqueues the corresponding
+   * v8 handle to be released during v8 gc.
+   *
+   * By the same token, you can use Refs to unwrap a Data_Wrap_Struct
+   * which has been generated in this fashion and call through to
+   * the underlying v8 methods. Suppose we are passed a VALUE `val`
+   * wrapping a v8::Object:
+   *
+   *     Ref<v8::Object> object(val);
+   *     object->Get(v8::String::New("foo"));
+   *
+   */
   template <class T>
   class Ref {
   public:
@@ -52,8 +53,8 @@ namespace rr {
     virtual ~Ref() {}
 
     /*
-    *  Coerce a Ref into a Ruby VALUE
-    */
+     *  Coerce a Ref into a Ruby VALUE
+     */
     virtual operator VALUE() const {
       if (handle.IsEmpty()) {
         return Qnil;
@@ -63,8 +64,8 @@ namespace rr {
     }
 
     /*
-    * Coerce a Ref into a v8::Local.
-    */
+     * Coerce a Ref into a v8::Local.
+     */
     inline operator v8::Handle<T>() const {
       return handle;
     }
@@ -80,11 +81,11 @@ namespace rr {
     }
 
     /*
-    * Pointer de-reference operators, this lets you use a ref to
-    * call through to underlying v8 methods. e.g
-    *
-    *     Ref<v8::Object>(value)->ToString();
-    */
+     * Pointer de-reference operators, this lets you use a ref to
+     * call through to underlying v8 methods. e.g
+     *
+     *     Ref<v8::Object>(value)->ToString();
+     */
     inline v8::Handle<T> operator->() const { return *this; }
     inline v8::Handle<T> operator*() const { return *this; }