Skip to content
Fetching contributors…
Cannot retrieve contributors at this time
206 lines (139 sloc) 7.13 KB
- 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'
- 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/
--- 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)
- 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! :)
- 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)
- 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
- 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
- '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
- 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 () {, 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;
- if (this.hasAttribute('builderClass')) this.getBuiderTarget() - to create a separate builder class for each metaclass
- + stem
- needs a test
- fix 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)
Something went wrong with that request. Please try again.