Prevent instantiation of abstract classes whose superclass isn't Object

Fixes #9

config/reek.yml

@@ -47,7 +47,7 @@ UncommunicativeModuleName:
 NestedIterators:
   ignore_iterators: []
   exclude: [
-    'AbstractType::ClassMethods#create_abstract_singleton_method'
+    'AbstractType::AbstractMethodDeclarations#create_abstract_singleton_method'
   ]
   enabled: true
   max_allowed_nesting: 1

lib/abstract_type.rb

@@ -13,31 +13,35 @@ module AbstractType
   # @api private
   def self.included(descendant)
     super
-    descendant.extend(ClassMethods)
+    create_new_method(descendant)
+    descendant.extend(AbstractMethodDeclarations)
   end
 
   private_class_method :included
 
-  module ClassMethods
-
-    # Instantiate a new object
-    #
-    # Ensures that the instance cannot be of the abstract type
-    # and must be a descendant.
-    #
-    # @example
-    #   object = AbstractType.new
-    #
-    # @return [Object]
-    #
-    # @api public
-    def new(*)
-      if superclass.equal?(Object)
+  # Define the new method on the abstract type
+  #
+  # Ensures that the instance cannot be of the abstract type
+  # and must be a descendant.
+  #
+  # @param [Class] abstract_class
+  #
+  # @return [undefined]
+  #
+  # @api private
+  def self.create_new_method(abstract_class)
+    abstract_class.define_singleton_method(:new) do |*args, &block|
+      if equal?(abstract_class)
         raise NotImplementedError, "#{inspect} is an abstract type"
       else
-        super
+        super(*args, &block)
       end
     end
+  end
+
+  private_class_method :create_new_method
+
+  module AbstractMethodDeclarations
 
     # Create abstract instance methods
     #
@@ -109,5 +113,5 @@ def create_abstract_instance_method(name)
       end
     end
 
-  end # module ClassMethods
+  end # module AbstractMethodDeclarations
 end # module AbstractType

spec/unit/abstract_type/class_methods/abstract_method_spec.rb → spec/unit/abstract_type/abstract_method_declarations/abstract_method_spec.rb

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe AbstractType::ClassMethods, '#abstract_method' do
+describe AbstractType::AbstractMethodDeclarations, '#abstract_method' do
   subject { object.abstract_method(:some_method) }
 
   let(:object)   { Class.new { include AbstractType } }

spec/unit/abstract_type/class_methods/abstract_singleton_method_spec.rb → spec/unit/abstract_type/abstract_method_declarations/abstract_singleton_method_spec.rb

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe AbstractType::ClassMethods, '#abstract_singleton_method' do
+describe AbstractType::AbstractMethodDeclarations, '#abstract_singleton_method' do
   subject { object.abstract_singleton_method(:some_method) }
 
   let(:object)   { Class.new { include AbstractType } }

spec/unit/abstract_type/class_methods/included_spec.rb → spec/unit/abstract_type/abstract_method_declarations/included_spec.rb

@@ -9,9 +9,9 @@
   let(:klass)  { Class.new       }
 
   it 'extends the klass' do
-    klass.singleton_class.should_not include(described_class::ClassMethods)
+    klass.singleton_class.should_not include(described_class::AbstractMethodDeclarations)
     klass.send(:include, subject)
-    klass.singleton_class.should include(described_class::ClassMethods)
+    klass.singleton_class.should include(described_class::AbstractMethodDeclarations)
   end
 
   it 'delegates to the ancestor' do

spec/unit/abstract_type/class_methods/new_spec.rb → spec/unit/abstract_type/module_methods/create_new_method_spec.rb

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe AbstractType::ClassMethods, '#new' do
+describe AbstractType, '.create_new_method' do
   context 'with arguments' do
     subject { object.new(:foo) }
 
@@ -46,4 +46,22 @@ def initialize(foo)
       specify { expect { subject }.to raise_error(NotImplementedError, "#{object} is an abstract type") }
     end
   end
+
+  context 'on an class that doesn\'t have Object as its superclass' do
+    subject { object.new }
+
+    let(:abstract_type) { Class.new(RuntimeError) { include AbstractType } }
+
+    context 'called on a subclass' do
+      let(:object) { Class.new(abstract_type) }
+
+      it { should be_instance_of(object) }
+    end
+
+    context 'called on the class' do
+      let(:object) { abstract_type }
+
+      specify { expect { subject }.to raise_error(NotImplementedError, "#{object} is an abstract type") }
+    end
+  end
 end