TASKS
=====

- test Joose.O.* helpers (partially done)

- derive 'stable' branch (should track releases of Task.Joose.Stable)

- merge Joose3 to 'master'

- add simple attribute 'defaultMethodClass' ala 'defaultAttributeClass'


DOCUMENTATION
=============

- document internals, notably the introspection API
    -- properties hierarchy (Property -> PropetySet -> Mutable -> Composition -> Stem)
    -- property's life stages (preApply/apply/unapply/postUnApply)
    
    -- brief description of built-in properties (attributes/methods/method modifiers/requirements)
    
    -- meta levels (proto/managed/meta)
        --- reasons for the 3rd level
        
    -- life stages of class
        --- initialize/extractConstructor/adaptConstructor/construct/prepareProps/extractSuperClass/
            processSuperClass/adaptPrototype/finalize/processStem/extend/
        --- class mutation (extend, stem open/closed)
    
    -- namespaces and class declaration
        --- declaration (with helpers, goes trough the Joose.Namespace.Manager)
        --- mutation (bypass the Joose.Namespace.Manager, managed by metaclass)
        --- Joose.Namespace.Keeper


- Joose.Cookbook
    -- add receipts for:
        --- adding new builder
        --- overriding a default attribute metaclass
         
    
- Joose.Manual 
   -- Installation 
        --- check the procedure on Mac OS
        --- verify that procedure works on several platforms (CPAN Testers at least) especially on Windows  


- document how class can be used as role (w/o inherited properties)
- replace the examples for 'static' with ones from real world (KiokuJS)



BENCHMARKING
============

- add benchmarking capabilities to Test.Run (or create a separate benchmarking tool)

- create a benchmark suite, and measure the:
    -- startup time (of Joose itself)
    -- class declaration time
    -- class mutation time
    -- class instantiation time (notably with traits)
    
- track the statistics in Changes file 

- optimize everything! :)



PERFORMANCE (depends on BENCHMARKING)
=====================================

- convert all OVERRIDE modifiers in core to AROUND? (need to benchmark them 1st)

- implement optimization for methods&OVERRIDE modifiers w/o calls to `SUPER` in body. Inline them directly, w/o wrappers. 
  Probably should be configurable, to avoid increasing of startup overhead.

- reduce the core codebase till the 6-7Kb after YUI+gzip (after the core refactoring, see below)



REFACTORING
===========

- rewrite the core in a bit more functional style - remove 'unApply/postUnapply' stages 
    should give noticeable speed-up for class declarations/mutations, as the whole 2 stages won't be
    propagated across all properties  
    we'll just clear the prototype and then re-apply it from scratch, 
    plus - we'll also receive a noticeable reduce of the codebase

- make `builderClass` and `stemClass` attributes private (as they are checked during normal class mutations also)

- sanitize the `create` method of Joose.Namespace.Manager

- make all stem elements lazy, so class w/o modifiers for example won't spent time for them

- introduce subs - degraded methods w/o ability to call SUPER

EXTENSIONS
==========


- JooseX.Builder.Also 
    -- should allow implicit ordering of builders, to address the Rhino issues (which iterates over properties randomly)
     and allow multiple modifiers in the same class

- JooseX.Type
    -- every class is a type
    -- every role is a type?
    -- types deriving (check Moose)

- JooseX.Attribute:
    -- delegation
    -- predicating/clearing (goes into core)
    -- typing, coercion
    -- traits for attributes (test)

- JooseX.Method.Overloaded (multi-methods, depending from calling signature), depends on JooseX.Type
    
        
- JooseX.Method.Labeled (attach some meta-info to methods)
    or rather
- JooseX.Property.Labeled (attach some meta-info to any property (notable attribute))
    

- JooseX.Detach - allow detaching/applying traits at arbitrary run-time moments
    clean implementation requires the `__proto__` support


IDEAS
=====

- 'immutable' builder (indicates that class/role won't mutate). Only matter for Roles, as mutation of classes doesn't trigger
  the changes in sub/super classes. 
    

- some kind of obfuscator to reduce the codebase size?? (function () { var a='Joose', b='Managed'; top[a][b] etc })()
- try Closure compacter


- "immutable traits" (should have name) - cache the derived meta-class, then re-use it, instead of re-creating for each instance
   should give cheap "lightweight" traits

- add alias 'static' for 'my'? (reserved word)

- property set & stem should only provide the composition logic, `apply/unapply` logic should be delegated to meta
  (in form of hooks?)

- only schedule the calls to `preApply/postUnApply` when it explicitly asked by attribute? 
    (currently just skipped for requirements for example)

- merge advanced attribute Role (Joose.Managed.Attribute.Builder) into bootstrap role (should give small startup boost) 
- merge bootstrap role into managed class






DONE
====

- add exception for inheritance from nothing ( isa : null )
- ability to freely inherit from non-Joose superclasses
    -- extensive test suite
    -- implementation
- JooseX.Meta.Parameterized (aka parameterized roles, + classes)
- add SKIP and TODO methods to Test.Run
- inter-op with NodeJS
- ability to specify the method for attribute initialization ("builder" in Moose meaning)
- alias static methods (not properties) to the constructor (should be delegates to 'my') 
    Some.Class.method = function () { 
        this.my.method.apply(this.my, arguments) 
    }
- allow regexes as initialization values for advanced attributes
- fix JSAN shell 'install' command (prefix)
- release Module::Build::Functions (CSJ)
- release Module::JSAN
- JooseX.Attribute.Accessor.Unified - getter and setter as single function
- JooseX.Class.Singleton; http://gist.github.com/243923
- if (this.hasAttribute('builderClass')) this.getBuiderTarget() - to create a separate builder class for each metaclass
- + stem
- needs a test
- fix OpenJSAN.org html extraction method
- release JSAN::Shell
- rewrite 'my' Singleton as Class methods (and create a separate Singleton core metaclass or JooseX)
- refactor advanced attributes from roles to adding methods directly (should be well test-covered first)
- refactor methods & modifiers to reduce overhead
- migrate AUGMENT modifier to closures
- anonymous classes
- refactor helpers
- fix multiple failures under FF3.5
- does for superclasses
- migrate to github
- add override check for PUT modifiers
- fix namespace managers executeIn to omit the args?
- refactor addRole (add something like 'beforeAdd' hook, which is very often needs to be overridden)
- global 'traits' config? to apply traits immediatly after instance creation?
- Class as Role? spec&implemented or remove
- subclass builder and stem classes on-demand only
- BUILD method to prepare the arguments passed to constructor
- refactor Joose.Helper to a global "instantiator" of classes. Then it will be possible to apply roles to it, to globally modify the class creation process
- merge Containable to Mutable
- cleanClone of Stem move to Composition
- fix frames double loading in Opera (Test.Run)
