discarded static() approach due to syntax error. Using Class.class for static variables

middleclass.lua

@@ -4,26 +4,28 @@
 -- Based on YaciCode, from Julien Patte and LuaObject, from Sebastien Rocca-Serra
 -----------------------------------------------------------------------------------------------------------------------
 
-local _nilf = function() end -- empty function
-
 local _classes = setmetatable({}, {__mode = "k"})
 
-function checkClass(theClass, methodName)
-  assert(_classes[theClass], "Make sure that you are using 'Class:" .. methodName .. "' instead of 'Class." .. methodName .. "')")
+function class(name, superClass, ...)
+  superClass = superClass or Object
+  return superClass:subclass(name, ...)
 end
 
+
+
 Object = {
-  name = "Object", __mixins = {}, __classDict = {}, __instanceDict = {},
+  name = "Object", __mixins = {}, class = {}, __instanceDict = {},
   __metamethods = { '__add', '__call', '__concat', '__div', '__le', '__lt', 
                     '__mod', '__mul', '__pow', '__sub', '__tostring', '__unm' }
 }
 
 setmetatable(Object, {
-  __tostring = function() return "class Object" end
+  __tostring = function() return "class Object" end,
+  __index = Object.class
 })
 
-function Object:allocate()
-  checkClass(self, 'allocate')
+function Object.class:allocate()
+  assert(_classes[self], "Make sure that you are using 'Class:allocate' instead of 'Class.allocate'")
   return setmetatable({ class = self }, self.__instanceDict)
 end
 
@@ -47,7 +49,9 @@ end
 
 _classes[Object] = true
 
-function Object:subclass(name)
+function Object.class:subclass(name)
+  assert(_classes[self], "Make sure that you are using 'Class:subclass' instead of 'Class.subclass'")
+  assert( type(name)=="string", "You must provide a name(string) for your class")
   local theSubClass = { name = name, superclass = self, __classDict = {}, __mixins={} }
   return theSubClass
 end
@@ -126,11 +130,6 @@ function includes(mixin, aClass)
   return includes(mixin, aClass.superclass)
 end
 
--- Creates a new class named 'name'. Uses Object if no baseClass is specified.
-function class(name, baseClass, ...)
-  baseClass = baseClass or Object
-  return baseClass:subclass(name, ...)
-end
-
 ]]
 
+

spec/middleclass-spec.lua

@@ -21,7 +21,7 @@ context( 'Object', function()
 
   context('bootstrapping', function()
     test('Object has two dictionaries and mixins properly set up', function()
-      for _,m in pairs{'__mixins', '__classDict', '__instanceDict'} do
+      for _,m in pairs{'__mixins', 'class', '__instanceDict'} do
         assert_type(Object[m], "table")
       end
     end)
@@ -80,49 +80,73 @@ context( 'Object', function()
   end)
 
   context( 'subclass', function()
-    context( 'when given a name', function()
+
+    test( 'throws an error when used without the :', function()
+      assert_error(function() Object.subclass() end)
+    end)
+
+    context( 'when given a class name', function()
 
       local MyClass = Object:subclass('MyClass')
 
-      test('returns a class with the correct name', function()
+      test('it returns a class with the correct name', function()
         assert_equal(MyClass.name, 'MyClass')
       end)
 
-      test('returns a class with the correct superclass', function()
+      test('it returns a class with the correct superclass', function()
         assert_equal(MyClass.superclass, Object)
       end)
     end)
+
+    context( 'when name is given', function()
+      test( 'it throws an error', function()
+        assert_error( function() Object:subclass() end)
+      end)
+    end)
+
+  end)
+
 end)
 
 
 
+context( 'class()', function()
+
+  context( 'when given no params', function()
+    test( 'it throws an error', function()
+      assert_error(class)
+    end)
+  end)
+
+  context( 'when given a name', function()
+    local TheClass = class('TheClass')
+
+    test( 'the resulting class has the correct name', function()
+      assert_equal(TheClass.name, 'TheClass')
+    end)
+
+    test( 'the resulting class has Object as its superclass', function()
+      assert_equal(TheClass.superclass, Object)
+    end)
+  end)
+--[[
+  context( 'when given a name and a superclass', function()
+    local TheSuperClass = class('TheSuperClass')
+    local TheSubClass = class('TheSubClass', TheSuperClass)
+
+    test( 'the resulting class has the correct name', function()
+      assert_equal(TheClass.name, 'TheClass')
+    end)
+
+    test( 'the restulting class has the correct superclass', function()
+     assert_equal(TheSubClass.superclass, TheSuperClass)
+    end)
+  end)
+]]
 end)
 
 --[[
-
-  context( 'When creating a direct subclass of Object', function()
-
-    context( 'using Object:subclass("name")', function()
-      local MyClass = Object:subclass('MyClass')
-
-      test( 'should have its name correctly set up', function()
-        assert_equal(MyClass.name, 'MyClass')
-      end)
-
-      test( 'should have Object as its superclass', function()
-        assert_equal(MyClass.superclass, Object)
-      end)
-    end)
-
-    context( 'When no name is given', function()
-      test( 'should throw an error', function()
-        assert_false( pcall(Object.subclass, Object) )
-      end)
-    end)
-
-  end)
-
-  context( 'An instance attribute', function()
+context('an instance attribute', function()
   local Person = class('Person')
   function Person:initialize(name)
     self.name = name
@@ -144,6 +168,7 @@ end)
     assert_equal(pete.name, 'pete')
     assert_equal(pete.age, 31)
   end)
+  
 end)
 
   context( 'An instance method', function()
@@ -351,41 +376,7 @@ end)
 
 end)
 
-context( 'class', function()
 
-  context( 'When creating a class', function()
-
-    context( 'using class("name")', function()
-      local TheClass = class('TheClass')
-
-      test( 'should have the correct name', function()
-        assert_equal(TheClass.name, 'TheClass')
-      end)
-
-      test( 'should have Object as their superclass', function()
-        assert_equal(TheClass.superclass, Object)
-      end)
-    end)
-
-    context( 'using class("name", AClass)', function()
-      local TheSuperClass = class('TheSuperClass')
-      local TheSubClass = class('TheSubClass', TheSuperClass)
-
-      test( 'should have the correct superclass', function()
-       assert_equal(TheSubClass.superclass, TheSuperClass)
-      end)
-    end)
-
-    context( 'using no name', function()
-      test( 'class() should throw an error', function()
-        assert_error(class)
-      end)
-    end)
-  
-  end)
-    
-
-end)
 
 
 context( 'includes', function()