Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP

0.2.4

GNU ease.js 0.2.4 released [stable]
This is a maintenance release correcting a number of bugs---most of which
were introduced in v0.2.3---addressing primarily ECMAScript 3
incompatibilities. Users needing to support ES3 environments (notably,
IE<=8) should consider v0.2.3 to be broken.

v0.2.3 was released last week on Jul 28.

Changes between 0.2.3 and 0.2.4:
  * [bugfix] method.super references in ease.js and test cases are now
    ES3-compatible

  * [bugfix] The Global prototype introduced in v0.2.3 used an
    implementation that IE<=8 did not support; now using an alternative

  - [bugfix] Interface.isInstanceOf now correctly operates as documented in
    the interoperability section of the manual
    - When passed an object whose constructor is not an ease.js class, it
      now falls back to Interface.isCompatible (as it should have).

  - [bugfix] Corrected test broken by Node.js 0.10.27
    - See commit cef45cd for details on what changed within Node.js.

  Trait support is currently under development and will be undocumented
  until v0.3.0; it is included currently as a preview and is functional and
  comprehensively tested, but incomplete.

  * [preview] [bugfix] Non-argument traits now apply an empty array to
    `__mixin` instead of `undefined`, which is unsupported by ES3

Getting GNU ease.js
-------------------
Here are the compressed sources and a GPG detached signature[*]:
  https://ftp.gnu.org/gnu/easejs/easejs-0.2.4.tar.gz
  https://ftp.gnu.org/gnu/easejs/easejs-0.2.4.tar.gz.sig

Alternative download options are available at:
  http://www.gnu.org/software/easejs/download.html

[*] Use a .sig file to verify that the corresponding file (without the
.sig suffix) is intact.  First, be sure to download both the .sig file
and the corresponding tarball.  Then, run a command like this:

  gpg --verify easejs-0.2.4.tar.gz.sig

If that command fails because you don't have the required public key,
then run this command to import it:

  gpg --keyserver keys.gnupg.net --recv-keys 8EE30EAB

and rerun the 'gpg --verify' command.

Free Your JavaScript!
---------------------
<http://www.gnu.org/software/easejs/whyfreejs.html>

See the FSF's Free JavaScript Campaign at
  <https://fsf.org/campaigns/freejs>.

Are you a JavaScript developer? Consider joining the campaign's JavaScript
Developers Task Force mailing list at
  <https://lists.gnu.org/mailman/listinfo/js-devs-task-force>.

About GNU ease.js
-----------------
GNU ease.js is a classical object-oriented framework for JavaScript,
intended to eliminate boilerplate code and "ease" the transition into
JavaScript from other object-oriented languages. Features include simple and
intuitive class definitions; classical inheritance; abstract classes and
methods; traits as mixins; interfaces; public, protected, and private access
modifiers; static and constant members; and more. Please see the
comprehensive documentation at
<https://www.gnu.org/software/easejs/manual.html> for more information,
examples, and implementation details.

0.2.3

GNU ease.js 0.2.3 released [stable]
This is the fourth release of the 0.2 series as part of the GNU project; it
is primarily a maintenance release, but does introduce a significant
(preview and undocumented) feature---parameterized traits.  A generic
`super` method has also been added to satisfy more sophisticated subtyping
that `__super` alone cannot handle.

Changes between 0.2.2 and 0.2.3:
  * `super` method now provided by method override wrapper
    - Allows invoking arbitrary method on supertype to handle cases where
      `__super` is not sufficient
    - Documentation added to manual under the heading of ``Arbitrary
      Supertype Method Invocation''
    - Anyone relying on undocumented internal properties to achieve this
      effect should now use this method instead.

  - ease.js and its test cases now conform to ES5 strict mode

  - Began ease.js metadata storage refactoring; those relying on
    undocumented properties (e.g. ___$$*$$) should take note
    - Please do not rely on undocumented behavior

  - Test runner now passes option arguments to Node.js
    - e.g. --debug and --debug-brk

  - [bugfix] Subtypes of prototype subtypes no longer clobber ease.js
    metadata

  Trait support is currently under development and will be undocumented
  until v0.3.0; it is included currently as a preview and is functional and
  comprehensively tested, but incomplete.

  * [preview] Parameterized traits
    - C' = C.use( T( ...params ) ); ...params passed to T#__mixin by
      reference upon instantiation of C'
    - See NEWS (or website blog) and test cases for rationale and examples

  - [preview bugfix] Corrected __length metadata on trait virtual proxies

  - [preview bugfix] Corrected virtual non-overridden trait methods

Getting GNU ease.js
-------------------
Here are the compressed sources and a GPG detached signature[*]:
  https://ftp.gnu.org/gnu/easejs/easejs-0.2.3.tar.gz
  https://ftp.gnu.org/gnu/easejs/easejs-0.2.3.tar.gz.sig

Alternative download options are available at:
  http://www.gnu.org/software/easejs/download.html

[*] Use a .sig file to verify that the corresponding file (without the
.sig suffix) is intact.  First, be sure to download both the .sig file
and the corresponding tarball.  Then, run a command like this:

  gpg --verify easejs-0.2.3.tar.gz.sig

If that command fails because you don't have the required public key,
then run this command to import it:

  gpg --keyserver keys.gnupg.net --recv-keys 8EE30EAB

and rerun the 'gpg --verify' command.

Free Your JavaScript!
---------------------
<http://www.gnu.org/software/easejs/whyfreejs.html>

See the FSF's Free JavaScript Campaign at
  <https://fsf.org/campaigns/freejs>.

Are you a JavaScript developer? Consider joining the campaign's JavaScript
Developers Task Force mailing list at
  <https://lists.gnu.org/mailman/listinfo/js-devs-task-force>.

About GNU ease.js
-----------------
GNU ease.js is a classical object-oriented framework for JavaScript,
intended to eliminate boilerplate code and "ease" the transition into
JavaScript from other object-oriented languages. Features include simple and
intuitive class definitions; classical inheritance; abstract classes and
methods; traits as mixins; interfaces; public, protected, and private access
modifiers; static and constant members; and more. Please see the
comprehensive documentation at
<https://www.gnu.org/software/easejs/manual.html> for more information,
examples, and implementation details.

0.2.2

GNU ease.js 0.2.2 released [stable]
This is the third release of the 0.2 series with a focus on interoperability
with vanilla ECMAScript/JavaScript. Three bugfixes address potential issues
when dealing with native prototypes. Additionally, GNU ease.js now considers
non-ease.js objects to adhere to an interface (without having to implement
it) so long as the object implements all methods and the proper number of
arguments, which allows users to integrate with ease.js classes without
having to use ease.js themselves. It further allows defining interfaces for
existing objects to ensure API conformance. Finally, to make definitions
more concise and more natural to prototypal developers, underscore-prefixed
members are now implicitly private; this can be overridden with an explicit
access modifier.

Changes between 0.2.1 and 0.2.2:
  * [doc] Added interoperability chapter to manual.

  * Members with an underscore prefix (e.g. _foo) are now implicitly
    private.
    - This can be overridden by explicitly specifying an access modifier.
    - Follows common conventions in modern object-oriented languages and
      permits concise definitions that are more natural to users of
      JavaScript's native prototype model.
    * This is backwards-incompatible if there is code that accesses
      underscore-prefixed members as public or protected without explicitly
      providing the visibility keyword in the member definition.

  * Interfaces are now interoperable with vanilla ECMAScript objects
    (including prototypes).
    - This allows for runtime polymorphism within ease.js methods without
      having to use ease.js.
    - Also allows creating interfaces for pre-existing objects (e.g. W3C DOM
      objects) to ensure adherence to an API.

  * Generated classes now have an `asPrototype` method for use as a
    constructor prototype.
    - Defers execution of class constructor, allowing prototypal subclassing
      (for those preferring not to use ease.js, but wish to extend a class
      generated from it).

  * [bugfix] Classes inheriting from prototypes will now properly proxy
    assignments to properties on the prototype.
    - Note that ease.js can only detect properties that are initialized in
      the prototype's constructor; otherwise, you must manually declare it
      public within the class definition to ensure proper proxying.

  - [bugfix] Classes inheriting from prototypes will now properly handle
    method overrides.
    - Parent prototype methods are implicitly virtual, unlike ease.js
      methods; see test/Class/InteropTest.js for rationale.

  - [bugfix] Class.isInstanceOf once again attempts blind native instanceof
    without preemptive function check.
    - v0.2.1 first checked to see if the argument was a function to prevent
      use of a try/catch; unfortunately, the proprietary browser IE9+ seems
      to treat certain DOM constructors (e.g. HTMLElement) as objects rather
      than functions, yet the `instanceof` keyword works with them. This
      reverts that change.

  Trait support is currently under development and will be undocumented
  until v0.3.0; it is included currently as a preview and is functional and
  comprehensively tested.

    - [preview] Named trait staging of the form Trait("Foo") implemented
      (analogous to Class("Foo")) and will no longer throw an obscure error.

    - [preview] Trait API now exposed in combined source file.
      - The v0.2.0 release exposed Trait via index.js, but the combined file
        (intended for use client-side) was overlooked.

Getting GNU ease.js
-------------------
Here are the compressed sources and a GPG detached signature[*]:
  https://ftp.gnu.org/gnu/easejs/easejs-0.2.2.tar.gz
  https://ftp.gnu.org/gnu/easejs/easejs-0.2.2.tar.gz.sig

Alternative download options are available at:
  http://www.gnu.org/software/easejs/download.html

[*] Use a .sig file to verify that the corresponding file (without the
.sig suffix) is intact.  First, be sure to download both the .sig file
and the corresponding tarball.  Then, run a command like this:

  gpg --verify easejs-0.2.2.tar.gz.sig

If that command fails because you don't have the required public key,
then run this command to import it:

  gpg --keyserver keys.gnupg.net --recv-keys 8EE30EAB

and rerun the 'gpg --verify' command.

Free Your JavaScript!
---------------------
<http://www.gnu.org/software/easejs/whyfreejs.html>

See the FSF's Free JavaScript Campaign at
  <https://fsf.org/campaigns/freejs>.

Are you a JavaScript developer? Consider joining the campaign's JavaScript
Developers Task Force mailing list at
  <https://lists.gnu.org/mailman/listinfo/js-devs-task-force>.

About GNU ease.js
-----------------
GNU ease.js is a classical object-oriented framework for JavaScript,
intended to eliminate boilerplate code and "ease" the transition into
JavaScript from other object-oriented languages. Features include simple and
intuitive class definitions; classical inheritance; abstract classes and
methods; traits as mixins; interfaces; public, protected, and private access
modifiers; static and constant members; and more. Please see the
comprehensive documentation at
<https://www.gnu.org/software/easejs/manual.html> for more information,
examples, and implementation details.

0.2.1

GNU ease.js 0.2.1 released [stable]
This is a maintenance release for the 0.2.0 series, including performance
enhancements and copyright assignment to the FSF. The copyright assignment
will allow the Free Software Foundation to enforce the project licenses and
ensures that GNU ease.js will always remain free (as in freedom).

Changes between 0.2.0 and 0.2.1:
  * [copyright] Copyright assigned to the Free Software Foundation
  * Private methods are no longer wrapped by ease.js
    - There is no longer a small performance hit for using private methods;
      they act as normal function calls on the prototype chain.
    - Will not thwart tail call optimization attempts (when implemented by
      engines).
  - Various v8 optimizations to resolve instances of unoptimized code in JIT
    engine
  - Removal of unnecessary proxy fallback code for a buggy proprietary web
    browser
  - Performance test cases now output data in a generic format
    - Began HTML report generation; nothing special yet.

Getting GNU ease.js
-------------------
Here are the compressed sources and a GPG detached signature[*]:
  https://ftp.gnu.org/gnu/easejs/easejs-0.2.1.tar.gz
  https://ftp.gnu.org/gnu/easejs/easejs-0.2.1.tar.gz.sig

Alternative download options are available at:
  http://www.gnu.org/software/easejs/download.html

[*] Use a .sig file to verify that the corresponding file (without the
.sig suffix) is intact.  First, be sure to download both the .sig file
and the corresponding tarball.  Then, run a command like this:

  gpg --verify easejs-0.2.1.tar.gz.sig

If that command fails because you don't have the required public key,
then run this command to import it:

  gpg --keyserver keys.gnupg.net --recv-keys 8EE30EAB

and rerun the 'gpg --verify' command.

About GNU ease.js
-----------------
GNU ease.js is a classical object-oriented framework for JavaScript,
intended to eliminate boilerplate code and "ease" the transition into
JavaScript from other object-oriented languages. Features include simple and
intuitive class definitions; classical inheritance; abstract classes and
methods; traits as mixins; interfaces; public, protected, and private access
modifiers; static and constant members; and more. Please see the
comprehensive documentation at
<https://www.gnu.org/software/easejs/manual.html> for more information,
examples, and implementation details.

Thank GNUs
----------
Thanks to Donald Robertson III for his help and guidance during the
copyright assignment process.

0.2.0

Announcing GNU ease.js v0.2.0 and the Importance of Free JavaScript
I am pleased to announce version 0.2.0 of GNU ease.js, the first of many
releases as part of the GNU project. This release contains exciting new
features, a couple bug fixes, and extensive test case cleanup. The project
has also been relicensed under the GNU GPLv3+ to help in the fight against
non-free JavaScript (detailed below).

Changes between 0.1.1 and 0.2.0:
  * [license] Relicensed under the GPLv3+ (previously LGPLv3+)
  * [bug fix] this.__super now mirrors stack rather than being clobbered
      after return from an ease.js method call
  * [bug fix] Protected member overrides of super-supertypes are now
      properly handled
  * [preview] Support for traits as mixins
    - This is an initial development preview of trait/mixin support
      (motivated heavily by Scala) and is currently undocumented in the
      manual.
    - Complete documentation will be available once remaining trait TODOs
      are addressed; until that time, see test/Trait/*Test.js for
      comprehensive examples and rationale. Performance tests are available
      in the test/perf directory for comparison with non-trait usage.
    - The implementation is stable, but not yet complete; see README.traits
      for more information.
  - Proxy methods and the associated `proxy' keyword are now documented
      (proxies were introduced in v0.1.1)
  + All older non-performance JS test cases are now part of the new suite
    - Extensive test cleanup and consistent formatting
    - All tests now contain rationale (as part of preceding comment block)
  - Now uses autotools; see README for instructions
  * v0.1 (LGPL'd) series is now unmaintained; users are encouraged to
      upgrade to 0.2.0 and be mindful of the terms of the new license

The project's new home is now at <https://www.gnu.org/software/easejs>;
easejs.org now redirects to the appropriate page, and so you should not need
to update your bookmarks.

Getting GNU ease.js
-------------------
Here are the compressed sources and a GPG detached signature[*]:
  https://ftp.gnu.org/gnu/easejs/easejs-0.2.0.tar.gz
  https://ftp.gnu.org/gnu/easejs/easejs-0.2.0.tar.gz.sig

Alternative download options are available at:
  http://www.gnu.org/software/easejs/download.html

[*] Use a .sig file to verify that the corresponding file (without the
.sig suffix) is intact.  First, be sure to download both the .sig file
and the corresponding tarball.  Then, run a command like this:

  gpg --verify easejs-0.2.0.tar.gz.sig

If that command fails because you don't have the required public key,
then run this command to import it:

  gpg --keyserver keys.gnupg.net --recv-keys 8EE30EAB

and rerun the 'gpg --verify' command.

About GNU ease.js
-----------------
GNU ease.js is a classical object-oriented framework for JavaScript,
intended to eliminate boilerplate code and "ease" the transition into
JavaScript from other object-oriented languages. Features include simple and
intuitive class definitions; classical inheritance; abstract classes and
methods; traits as mixins; interfaces; public, protected, and private access
modifiers; static and constant members; and more. Please see the
comprehensive documentation at
<https://www.gnu.org/software/easejs/manual.html> for more information,
examples, and implementation details.

The Importance of Making JavaScript Code Free
---------------------------------------------
[For more information on the FSF's Free JavaScript campaign, please see
<http://www.gnu.org/philosophy/javascript-trap.html>.]

Web pages increasingly include JavaScript code, which raises the same
ethical concerns as software written in any other language: Non-free
JavaScript can rob you of your right to study, modify, and share the
software that you are running.  Unlike traditional software, JavaScript
usually enters your machine without prompting and often without your
knowledge---the simple act of visiting a web page may install and execute
a non-free program within your web browser.

JavaScript provides an often frictionless cross-platform distribution
mechanism that can be exploited without your permission; this amplifies
the effects of some of the most insidious anti-features, such as spying
on your activities and tracking your movements.  If a web page executes
non-free code, how are you able to audit it (or have someone else do so
on your behalf) to ensure that it is not malicious?  Further, how are
you or others able to modify the software to remove the malicious code?
(Unfortunately, the latter can be complicated even with free JavaScript,
but it can be done.)

But non-malicious programs sometimes need changes too.  You deserve
control over all software that runs on your computer; why should you
sacrifice this freedom simply because JavaScript creates the illusion
of remote execution?

How many web sites have you visited today that download JavaScript
onto your computer?  How many of them respect your freedoms?  I chose
to license ease.js under the GPLv3+ because I believe that non-free
JavaScript should be eliminated, not enabled.  Please help to spread
the word and join me in writing free JavaScript; without it, we will
have an Internet that is locked away from free software users; this is
not the spirit in which the Internet was created.

More information on the JavaScript trap is available here:
  <http://www.gnu.org/philosophy/javascript-trap.html>.

To join in on the FSF's Free JavaScript campaign:
  <https://fsf.org/campaigns/freejs>

More information on free software and its freedoms:
  <http://www.gnu.org/philosophy/free-sw.html>

Thank GNUs
----------
Special thanks to Brandon Invergo for his help during the GNU submission
process and for his auto{conf,make} advice and patches; RMS for extensive
proofreading and advice on "The Importance of Making JavaScript Code Free";
and the many others at the FSF and GNU Project that were involved in this
process.

0.1.1

Version 0.1.1 release
This release primarily addresses a fix (partial implementation) for
ES5 getter/setter 'this' bindings, but does sneak in a couple other things.

  - [bugfix] Getter/setter 'this' binding now properly binds to the private
    visibility object (just as methosd do)
  - [bugfix] Documentation typo correction regarding class dfn keywords
  - [bugfix] Corrected warning console output (invocation was incorrect)
  - [bugfix] Corrected exception handling in XUnit-style tests

  - Project is now hosted on Savannah; copyright notices, etc have been
    added/corrected in order to comply with the project hosting guidelines.
  - Preliminary 'proxy' keyword support. Incomplete and undocumented; see commit
    d84b86 for more details.
  - Added chk-linelen tool
  - Added doc-html target
  - It is an ongoing effort to convert old test cases over to the new style

As mentioned in 79cbc7, the getter/setter implementation will be completed with
regards to overrides, the abstract keyword, proxies and method hiding at a later
(hopefully soon) date; this bug fix should be sufficient for the majority of
uses and corrects a major flaw. (Please note that the bug only affected ES5
getters/setters.)

Please see the commit messages between this tag and the last for more detailed
information.

0.1.0

First release
Happy holidays and happy new year from ease.js

This project has been a wonderfully rewarding experience. It has allowed me to
explore (in agonizing detail) the depths of JavaScript's prototype model and
gain a much greater understanding of the language itself. ease.js evolved from a
simple script to make the life of myself and my coworkers simpler ("ease" us
into Classical OO in JS) into a full-scale project that is now just over a year
old. While the initial design was fairly simple, I now find that I'm left with
more implementation ideas than I am actual implemented features.

ease.js is still very young. v0.1.0 represents an initial step in the life of
the project - getting it out there for people to use and observe; allowing
others to test the waters. There is a long road ahead and many exciting features
planned for the project. Thus far, it has far exceeded my goals and expectations,
but there is much work to be done.

I hope that this project is well-received among developers in the JavaScript
community. It touches upon what many consider to be a sensitive subject. Some
firmly believe that Classical OOP should be left out of JavaScript and that one
should instead stick to its prototypal model. While I fully respect the model,
and it does certainly have powerful applications, there are also situations
where the Classical OOP paradigm is also appropriate (some would argue more
appropriate). I have found ease.js to be invaluable during the development of
the project for which it was designed (software for my current employer). It has
allowed both myself and my coworkers to continue using a development model we
are familiar with, while exploring and making use of other paradigms where they
are appropriate. We have been able to do so without having to explore other
languages that support Classical OOP (for example, GWT, which compiles Java into
JavaScript).

It is important to understand that ease.js simply opens up, with greater
flexibility and simplicity, another paradigm which is closely related to the
Prototypal model (they are both Object-Oriented). One does not have to make use
of it should they prefer a different paradigm, even if the libraries they use
are written using ease.js. Ultimately, ease.js has to work with the restrictions
provided by the language. As such, one can think of ease.js as a prototype
builder. Each "class" created with ease.js is simply a prototype and can be used
in conjunction with any other JavaScript code. The reverse is also true - you
can use your existing code with ease.js and ease.js is capable of extending from
existing prototypes as if they were classes. Think of ease.js like a tool, /not/
a restriction. In fact, it would be bad practice to limit yourself to what
ease.js provides. JavaScript provides powerful features of its own. Therefore,
if you are using ease.js to aid in transition to JavaScript, be sure that you
continue to explore JavaScript itself.

One should also keep in mind that ease.js, while trying to maintain a Classical
Object-Oriented model that developers from common languages like Java, PHP, C++,
etc will be used to, did have to make certain design decisions that make sense
when working with JavaScript. Certain additional decisions were also made, after
great research (the majority of the time spent on this project was on paper, not
at the keyboard), that may set ease.js aside from other languages when getting
into finer details. While any Classical Object-Oriented developer should be able
to jump in with little effort and even little understanding of JavaScript, you
are still encouraged to take a look at the manual (http://easejs.org) and ensure
that you have a firm understanding of both what ease.js is doing and what it is
capable of doing. It also helps to take a look at the developer portion of the
documentation (Appendix B - Implementation Details / Rationale) to get a better
grasp on what ease.js is doing behind the scenes to better structure and
optimize your code. Even better, feel free to browse through ease.js's source
code and maybe even hack at ease.js yourself. See README.hacking for more
information on contributing to the project.

As was already mentioned, ease.js is under active development. Feel free to
check out the bugs/issues/feature requests on the website (http://easejs.org) to
see what is outstanding. If you find that you want a feature that isn't listed,
feel free to request it (it will, of course, have to be given careful
consideration to ensure it fits in line with the goals of the project). Since
the project will be changing so rapidly, I encourage you to keep checking back,
or keep a local copy of the Git repository to pull on occasion. Keep your eye
out for a mailing list as well.

As one can see by reading over this tag message, the Git repository itself is
used in place of a blog (perhaps some script will be developed in the future to
put all important commit/tag messages conveniently online much like a blog). One
can easily see long commit messages (shorter messages are unlikely to be
entries) by using `git log --log-size`. Tag messages can be shown with `git tag
-nN`, where N is the number of lines to be displayed.

One final mention is in order as to why this is the first release of the
project, over a year after it began. An inspection of the git repository will
yield, at this point, but one tag - this one. Although the repository has been
public during the entire course of its development (ease.js can be considered to
follow the Bazaar development model), ease.js has not been advertised to anyone.
I wished for the project to remain mostly under wraps until the first release.
This was for a very important reason - I did not want sudden API changes and any
potential incomplete features or bugs to stifle adoption or perception of the
project. With the release of v0.1.0, I can confidently say that the API has been
solidified and that backwards compatibility will be maintained throughout all
future releases, unless slowly deprecated over a number of major or minor
releases.

With that said, more information can be found in the manual, which has become a
project of its own. If you've read this far, thank you for your interest in the
project. I hope you find it useful in bringing the benefits of Classical OOP to
JavaScript.
Something went wrong with that request. Please try again.