Merge branch 'release/4.1.1'

Author: darko-mijic

.versions

@@ -28,7 +28,7 @@ [email protected]
 [email protected]
 [email protected]
 [email protected]
-local-test:space:base@4.0.2
+local-test:space:base@4.1.1
 [email protected]
 [email protected]
 [email protected]
@@ -52,7 +52,7 @@ [email protected]
 [email protected]
 [email protected]
 [email protected]
-space:base@4.0.2
+space:base@4.1.1
 space:[email protected]
 [email protected]
 [email protected]

CHANGELOG.md

@@ -1,5 +1,20 @@
 Changelog
 =========
+
+## 4.1.1
+- Improves the way mixins are applied to classes and ensures that:
+  - Sub classes always inherit all mixins applied to parent classes, even when this happens "later on"
+  - All sub classes inherit the static mixin properties, even after extending the base class
+
+- Adds the following helpers are added to `Space.Object` for convenience:
+  - **static**
+    - `MyClass.hasSuperClass()`
+    - `MyClass.superClass([key])` - either returns the super class constructor or static property/method
+    - `MyClass.subClasses()` - returns flat array of all sub classes
+  - **prototype**
+    - `myInstance.hasSuperClass()`
+    - `myInstance.superClass([key])` - same as static version but returns prototype props/methods
+
 ## 4.1.0
 - Adds `hasMixin()` instance method to Space.Object to check if the class has applied or inherited a specific mixin
 

package.js

@@ -1,7 +1,7 @@
 Package.describe({
   summary: 'Modular Application Architecture for Meteor.',
   name: 'space:base',
-  version: '4.1.0',
+  version: '4.1.1',
   git: 'https://github.com/meteor-space/base.git',
   documentation: 'README.md'
 });

source/object.coffee

@@ -1,6 +1,8 @@
 
 class Space.Object
 
+  # ============= PUBLIC PROTOTYPE ============== #
+
   # Assign given properties to the instance
   constructor: (properties) ->
     @_invokeConstructionCallbacks.apply(this, arguments)
@@ -14,13 +16,26 @@ class Space.Object
 
   toString: -> @constructor.toString()
 
+  hasSuperClass: -> @constructor.__super__?
+
+  # Returns either the super class constructor (if no param given) or
+  # the prototype property or method with [key]
+  superClass: (key) ->
+    sup = @constructor.__super__.constructor
+    if key? then sup.prototype[key] else sup
+
+  # Returns true if the passed in mixin has been applied to this or a super class
   hasMixin: (mixin) -> _.contains(@constructor._getAppliedMixins(), mixin)
 
+  # This method needs to stay separate from the constructor so that
+  # Space.Error can use it too!
   _invokeConstructionCallbacks: ->
     # Let mixins initialize themselves on construction
     for mixin in @constructor._getAppliedMixins()
       mixin.onConstruction?.apply(this, arguments)
 
+  # ============= PUBLIC STATIC ============== #
+
   # Extends this class and return a child class with inherited prototype
   # and static properties.
   #
@@ -128,8 +143,12 @@ class Space.Object
       initialize.apply(this, arguments);
     }')(Constructor)
 
+    # Add subclass to parent class
+    Parent._subClasses.push(Child)
+
     # Copy the static properties of this class over to the extended
     Child[key] = this[key] for key of this
+    Child._subClasses = []
 
     # Copy over static class properties defined on the extension
     if extension.statics?
@@ -203,18 +222,43 @@ class Space.Object
     else
       @_applyMixin(mixins)
 
+  # Returns true if this class has a super class
+  @hasSuperClass: -> @__super__?
+
   @isSubclassOf: (sup) ->
     isSubclass = this.prototype instanceof sup
     isSameClass = this is sup
     return isSubclass || isSameClass
 
+  # Returns either the super class constructor (if no param given) or
+  # the static property or method with [key]
+  @superClass: (key) ->
+    sup = @__super__.constructor
+    if key? then sup[key] else sup
+
+  # Returns a flat, uniq array of all sub classes
+  @subClasses: ->
+    subs = [].concat(@_subClasses)
+    subs = subs.concat(subClass.subClasses()) for subClass in subs
+    return _.uniq(subs)
+
+  # Returns true if the passed in mixin has been applied to this or a super class
   @hasMixin: (mixin) -> _.contains(@_getAppliedMixins(), mixin)
 
-  @_applyMixin: (mixin) ->
+  # ============= PRIVATE STATIC ============== #
+
+  @_subClasses: []
 
+  @_applyMixin: (mixin) ->
     # Add the original mixin to the registry so we can ask if a specific
     # mixin has been added to a host class / instance
-    @_registerMixin mixin
+    # Each class has its own mixins array
+    hasMixins = @_appliedMixins?
+    areInherited = hasMixins and @superClass('_appliedMixins') is @_appliedMixins
+    if !hasMixins or areInherited then @_appliedMixins = []
+
+    # Keep the mixins array clean from duplicates
+    @_appliedMixins.push(mixin) if !_.contains(@_appliedMixins, mixin)
 
     # Create a clone so that we can remove properties without affecting the global mixin
     mixinCopy = _.clone mixin
@@ -224,8 +268,11 @@ class Space.Object
     delete mixinCopy.onConstruction
 
     # Mixin static properties into the host class
-    _.extend(this, mixinCopy.statics) if mixinCopy.statics?
-    delete mixinCopy.statics
+    if mixinCopy.statics?
+      statics = mixinCopy.statics
+      _.extend(this, statics)
+      _.extend(sub, statics) for sub in @subClasses()
+      delete mixinCopy.statics
 
     # Give mixins the chance to do static setup when applied to the host class
     mixinCopy.onMixinApplied?.call this
@@ -234,7 +281,11 @@ class Space.Object
     # Copy over the mixin to the prototype and merge objects
     @_mergeIntoPrototype @prototype, mixinCopy
 
-  @_getAppliedMixins: -> @_appliedMixins ? []
+  @_getAppliedMixins: ->
+    mixins = []
+    mixins = mixins.concat(@superClass()._getAppliedMixins()) if @hasSuperClass()
+    mixins = mixins.concat(@_appliedMixins) if @_appliedMixins?
+    return _.uniq(mixins)
 
   @_mergeIntoPrototype: (prototype, extension) ->
     # Helper function to check for object literals only
@@ -248,22 +299,4 @@ class Space.Object
       else
         value = _.clone(value) if isPlainObject(value)
         # Set non-existing props and override existing methods
-        prototype[key] = value
-
-  @_registerMixin: (mixin) ->
-    # A bit ugly but necessary to check that sub classes don't statically
-    # inherit mixin arrays from their super classes
-    if @__super__?
-      superMixins = @__super__.constructor._appliedMixins
-      hasInheritedMixins = @_appliedMixins? and (superMixins is @_appliedMixins)
-    else
-      hasInheritedMixins = false
-
-    if hasInheritedMixins
-      # Create a shallow copy of the inherited mixins array
-      @_appliedMixins = @_appliedMixins.slice()
-    else
-      @_appliedMixins ?= []
-
-    # Keep the mixins array clean from duplicates
-    @_appliedMixins.push(mixin) if !_.contains(@_appliedMixins, mixin)
+        prototype[key] = value

tests/unit/object.unit.coffee

@@ -54,7 +54,6 @@ describe 'Space.Object', ->
         MyClass = Space.Object.extend('MyClass')
         expect(Space.resolvePath 'MyClass').to.equal(MyClass)
 
-
     describe "working with static class properties", ->
 
       it 'allows you to define static class properties', ->
@@ -82,6 +81,45 @@ describe 'Space.Object', ->
       expect(instance.first).to.equal 1
       expect(instance.second).to.equal 2
 
+  describe "inheritance helpers", ->
+
+    Base = Space.Object.extend {
+      statics: { prop: 'static', method: -> }
+      prop: 'prototype'
+      method: ->
+    }
+    Sub = Base.extend()
+    GrandSub = Sub.extend()
+
+    describe "static", ->
+
+      it "can tell if there is a super class", ->
+        expect(Sub.hasSuperClass()).to.be.true
+
+      it "can return the super class", ->
+        expect(Sub.superClass()).to.equal(Base)
+
+      it "can return a static prop or method of the super class", ->
+        expect(Sub.superClass('prop')).to.equal(Base.prop)
+        expect(Sub.superClass('method')).to.equal(Base.method)
+
+      it "can give back a flat array of sub classes", ->
+        expect(Base.subClasses()).to.eql [Sub, GrandSub]
+        expect(Sub.subClasses()).to.eql [GrandSub]
+        expect(GrandSub.subClasses()).to.eql []
+
+    describe "prototype", ->
+
+      it "can tell if there is a super class", ->
+        expect(new Sub().hasSuperClass()).to.be.true
+
+      it "can return the super class", ->
+        expect(new Sub().superClass()).to.equal(Base)
+
+      it "can return a static prop or method of the super class", ->
+        expect(new Sub().superClass('prop')).to.equal(Base::prop)
+        expect(new Sub().superClass('method')).to.equal(Base::method)
+
   describe 'mixins', ->
 
     it 'adds methods to the prototype', ->
@@ -122,17 +160,6 @@ describe 'Space.Object', ->
       TestClass.mixin myMixin
       expect(myMixin.onMixinApplied).to.have.been.calledOnce
 
-    it "does not apply mixins to super classes", ->
-      firstMixin = onDependenciesReady: sinon.spy()
-      secondMixin = onDependenciesReady: sinon.spy()
-      SuperClass = Space.Object.extend()
-      SuperClass.mixin firstMixin
-      SubClass = SuperClass.extend()
-      SubClass.mixin secondMixin
-      new SuperClass().onDependenciesReady()
-      expect(firstMixin.onDependenciesReady).to.have.been.calledOnce
-      expect(secondMixin.onDependenciesReady).not.to.have.been.called
-
     it 'can be defined as prototype property when extending classes', ->
       myMixin = { onMixinApplied: sinon.spy() }
       MyClass = Space.Object.extend mixin: [myMixin]
@@ -160,6 +187,30 @@ describe 'Space.Object', ->
       expect(instance.hasMixin(SecondMixin)).to.be.true
       expect(instance.hasMixin(ThirdMixin)).to.be.false
 
+    describe "mixin inheritance", ->
+
+      it "does not apply mixins to super classes", ->
+        firstMixin = {}
+        secondMixin = {}
+        SuperClass = Space.Object.extend mixin: firstMixin
+        SubClass = SuperClass.extend mixin: secondMixin
+        expect(SuperClass.hasMixin(firstMixin)).to.be.true
+        expect(SuperClass.hasMixin(secondMixin)).to.be.false
+        expect(SubClass.hasMixin(firstMixin)).to.be.true
+        expect(SubClass.hasMixin(secondMixin)).to.be.true
+
+      it "inherits mixins to children when added to base class later on", ->
+        LateMixin = { statics: { test: 'property' } }
+        # Base class with a mixin
+        BaseClass = Space.Object.extend()
+        # Sublcass with its own mixin
+        SubClass = BaseClass.extend()
+        # Later we extend base class
+        BaseClass.mixin LateMixin
+        # Sub class should have all three mixins correctly applied
+        expect(SubClass.hasMixin(LateMixin)).to.be.true
+        expect(SubClass.test).to.equal LateMixin.statics.test
+
     describe "onDependenciesReady hooks", ->
 
       it "can provide a hook that is called when dependencies of host class are ready", ->