Jasy

==============

Notes

- Splitted `jasy.core.BuildTool` and `jasy.core.OutputManager` into separate tools `jasy.build.Asset`, `jasy.build.Script` and `jasy.build.Style`. All of them are managed by `jasy.build.Manager`
- Renamed `jasy.js` to `jasy.script` and `Class` to `Script`- you might have to update your references as well. Goal for these changes was to unify the overall names of item types, parsing/processing implementation and build tools.


Changes

- Added support for optionally registering commands (for stylesheets, templates, ...) globally aka without any project name as a prefix.
- Re-added the `executeCommand` method for `Session` - got lost somehow.
- Added support for formatting/optimization of Stylesheets. Also improved location where flags for these settings are transferred into a settings object (now part of the Style engine).
- Added support for simple casing of `identifier`, `string` and `number` objects in stylesheets using `identifier`, ...
- Stability improvements for stylesheet processing with more edge cases fixed and improved error handling.
- Added support for "!important" in stylesheets and comparable expressions.
- Added support for special CSS argument lists to support multi value parameters inside CSS expressions e.g. linear-gradient(startColor startPos, endColor endPos) - CSS has definitely a lot of these edge cases.
- Added support for identifier based operations (plus/join, equals and not equals)
- Improved error handling when end-quote of strings is missing in Stylesheets

==============

Notes

- Updated required Python version to 3.3 as this is the version for which all development happens right now.
- Updated dependencies to Sphinx-1.2 and Pillow-2.3.
- Support for alternative translation formats have been finally removed. Now Jasy uses Gettext for all build-in translation requirements. There were basically unimplemented alternatives for Java property files and ICU data, but this was never implemented to be usable. Now the system basically only accepts `.po` files as input for translations and is much cleaner is this regard.

Major changes

The progress on the style sheet processing was enormous. A lot of new cases are now being dealt with. A lot of new tests have been added and code has been fixed to make them work.

- Caching for style sheets have been enabled. The system now should safely support all kind of include/require variants and improve re-execution times by usage of a good amount of cache infrastructure.
- Improved include processing for greater stability.
- Improved detection and handling of modification times and cache invalidation.
- Added support for `supports` and major improvements to support of `media`.
- Added support for `root` which is inspired by Sass-3.3's `at-root` command.
- Added support for the built-in CSS syntax `charset` and `page`.
- Many issues around mixin/extend mechanism have been fixed.
- Added support for placeholders inide selectors `header { &.-fullscreen {} }`
- Added support for BEM-syntax usage e.g. `.messagebox{ &--warning{} }`

Added support for a built-in template system to process Core-esque template files.

- Supports dynamic JS class representation of such a class for easy usage in applications.


Minor changes

- Preparations for supporting alternative text readers for `jasy.Class` e.g. to support things like CoffeeScript, templates etc. as input for class files.
- `jasy-style-util.py` supports a new task "reduced" to print out the tree just before compression.
- Added `isConfigName` to `jasy.core.Config` for validating if a filename is a config file is either JSON or YAML.
- Fixed issue with auto deleting config files during scaffolding of new projects.
- Improved output formatting of jasy.Doctor.
- Improved some logging levels to reduce output of new features e.g. profile ID generation.
- Fixed minor issues with Base62-based checkout folder names where automatic project ID generation failed for projects like Bootstrap.
- Played with alternative Markdown processor called Howdown. This one has the same performance like Misaka but offers a richer set of features (Markdown extensions). Unfortunately it crashes reproducable right now, so it's disabled for the moment. Issue was reported to the author: https://github.com/hhatto/python-hoedown/issues/5
- Added missing constructor to `jasy.item.Abstract`.
- Cleanup of imports in `jasy.item.Asset`.
- Renamed `kind` properties of all built-in items with the prefix `jasy.` so they are now called `jasy.Class`, `jasy.Asset`, ... This is mainly for extensibility of Jasy for new item types.

==============

Major changes

Added support for customizing projects structure

- Support for adding cuctom item types (not limited to Class, Style, Asset, Translation anymore)
- Added support to define the item type in manual content sections. No auto-handling anymore based on file extension!
- Added new and generic `addItem()`/`getItem()` to `Project` for easily manually adding items to the registry.
- Path to file ID transformation happens in each item type now, not centrally in `Project`.

Fine tuning for `Profile`

- Massive cleanup to implementation.
- Using new storage logic to generate unique IDs for each configuration using `getId()`.

Minor changes

- Updated Copyrights to 2014 ;)
- Minor fix for handling non existing asset data in `OutputManager`
- Removed handling of "xlf" extension for supporting ICU translations. Still not implemented. Makes no sense to keep reporting it.
- Removed filtering of projects inside resource folders of each projects. This should be pretty untypical and is a bad architecture choice. Warnings about this were removed as this effectively never produced a positive case as far as we know.

==============

Redistributed tasks between `Profile` and `Session`

Effectively everything related to the current build is in `Profile` e.g. permutation data is now part of Profile - not Session. Session just handles projects registration, initial setup etc.

Moved actual `build` from `Profile` to new `BuildTool`

The profile is now mainly used for configuration and state management. The build process itself did not feel as being a good place inside this class. The new `BuildTool` class now implements a simple application build logic.

Minor changes

- Support for query strings in assets e.g. to support SVG fonts correctly
- Minor output and logging improvements during session/profile initialization
- `Profile` is no longer auto initialized but requires being initiated by the author of the task.

==============

Major changes

Introduction of new profile object

The new object is created by `State` like the `Session` instance and is mainly used to hold all relevant build information e.g. destination paths, formatting of output, compression settings, etc. This profile will be used for having a serialized version for validating cache entries against (still TODO).

The `Profile` also contains a typical application build tool under its `build()` method. This is mainly thought for omitting repeative tasks inside comparable applications where mostly 90% of the build script were identical. Applications are still being able to use some variant of the old API but it's typically preferred to switch over to the new, much simpler API.

The `Profile` also exports all destination paths to the client and making them available via `jasy.Env` e.g. `jasy.folder.js` etc.

Integrated completely rewritten AssetManager (which replaces the old one)

- Removed support for profiles in asset system which is a major simplification and was only required by some edge cases at Zynga.
- New asset manager uses data from `Profile` for figuring out destination paths etc.
- Added support for auto tracking and registering of requested assets so that these are copied automatically to the destination just by requiring any details from them.
- Making asset methods available via new system command infrastructure to ask for asset details e.g. the build URL, image dimension, sprite data, etc. from within CSS or HTML templates.
- Improved and simplified implemention to support sprite sheets and image animations.

Added new command interface

The command interface is a new API on the `Session` object to make shared commands available all different areas of the tooling. This is currently used by the new `AssetManager` to register commands for quering image URLs, dimensions, etc. The new API is planned for being used in the processors for Stylesheets, Templates, HTML files, etc. Like for `jasylibrary.py` to offer new APIs to the tooling of other projects, authors might now also create a `jasycommand.py` for making own commands available to other projects. Like for `jasylibrary.py` these commands are prefixed by the unique `name` of the project defining them.

Continued work on style processor

- Major work on "execution" of style sheet code to process variables and system calls.
- New shared operation processor which is used by both, the Permutation and Execution engine to resolve comparisons, not-operators, etc.
- This version supports conditionals of variables (not just environment variables).
- Added new method `getMergedMTime()` for quering for the `include` respecting modification time (figuring out the last changed file and returns that time instead of just the top-level file).
- Worked on include mechanics to improve stability of include implementation.
- The syntax of expressions have been modified. These now have to be wrapped inside `expr()` for evaluation when not part of an assignment or conditional.
- Added a lot of new tests for validating the functionality of the new features. Updated old tests to new APIs, too.

Minor changes through style processor work

- Temporary disabled style result caches to omit issues with too agressive caching (needs to be fixed with a later release).
- Added command wrapper `executeCommand` to `Util` for making command execution and result processing reuseable inside the style processor.
- Added new `castNativeToNode()` to `Util` for translating Python values into matching `Node` instances. This new class is used during variable processing (execution) for replacing operations with result nodes.
- Cleanup of style compressor from unnecessary prefixes and operators.
- Added support for slashes inside property values e.g. `font-size: 10px/1.2;`.
- Added support for raw values via `raw("some css string");`. This is mainly used for supporting non-CSS values like old IE filter values (opacity, gradient, etc.).
- Added support for CSS `font-face`.
- Added new `noscope` flag to `Node` for marking specific blocks as not being scope relevant. This is currently used for if/else blocks to allow the content blocks to modify the parent block instead of scoping into the own block. This allows for defining/overriding variables inside if/else blocks.
- Minor fixes for CSS selector support not correctly supporting specific selector variants e.g. `&[attribute]`.
- Added support for reducing unneeded blocks (which are not allowed in CSS anyway but might be used for scoping variables) so that their content is injected in place of the original block.
- Removed some unsupport syntax constructs will processed inside the `Tokenizer` but not available in the `Parser`.

Cleanup of sprite sheet generator

- Removed rotation feature (not relevant for most use cases and never was finished regarding implementation) and cleaned up a ton of code inside the whole sprite generator implementation.
- Simplified import logic for Python image module. Completely switched to Pillow which is much better than good old PIL nowadays.




Minor changes

- Added support for return values from tasks (returning error codes from tasks ends Jasy with exactly the same error code now - thanks to Sebastian Fastner)
- Reworked integration of documentation generator to correctly work with [ReadTheDocs](http://jasy.readthedocs.org/en/latest/)
- Let `ImageInfo` class make use of shared implementation of file SHA1 hashing in `File` instead of using a local implementation.
- Removal of preliminary module for file system daemon support.
- Updated dependencies to new versions.
- Minor fixes for supporting YAML configuration files.
- Added new asset type info for `.md` and `.yaml` (both as "text").
- Moved `jasy.js.parse.ScopeData` to `jasy.parse.ScopeData` and updated references accordingly.

==============

Stylesheets

Short Feature Overview

There is a fullblown CSS parser/compressor with custom features you know from LESS, Sass and Stylus. There are still a few (small and big) outstanding features but this is a good start:

- Added full blown CSS-like parser with added features like includes, dependencies, mixins, extends and variables.
- Added AST reducer to reduce custom style format into something CSS compatible.
- Added compressor for AST to generated CSS out of the reduced tree. Supports both compressed output and some basic formatting with line breaks.
- Styles are being loaded from the source folder `styles` and should be typically written out to `css` (by convention).
- Important: These stylesheets are not be part of the asset handling anymore. You have to generate the CSS files in both `source` and `build` targets. There might also be changes required for loading other assets like images from within such a stylesheet. Asset handling for stylesheets is not yet included.

Changes to other APIs

To support the new stylesheet feature changes to other APIs were required:

- Revamped script APIs to be more explicitely oriented on scripts to make room for adding matching APIs for stylesheet processing e.g. `storeKernelScript()` instead of `storeKernel()`, `storeLoaderScript()` instead of `storeLoader()`, etc.
- Added abstract Classes `Resolver`, `Sorter` and `Node` to being used by both the stylesheet and script infrastructure. Therefor changed a few APIs to match generic usability of methods e.g. `add()` instead of `addClass()`, `getSorted()` instead of `getSortedClasses()`, etc.
- Added new API to output manager `storeCompressedStylesheet(styles)` for compressing a sorted set of stylesheets.
- Changed conventions to unify stylesheets and scripts: Put all your generated JavaScript files into `js` instead of `script` to match the file extension. This typically requires minor changes to the way these files are loaded into the HTML e.g. via `ScriptLoader`.
- Added abstract `FlagSet` class which is used for storing the flags for optimization and formatting settings in a unified way.
- Removed `name` support in `MetaData` as this is mainly not used anymore through the introduction of `content` sections inside `jasyproject` files.


Other Changes/Optimizations:

- Let travis.ci use Python-3.3 instead of Python-3.2
- Reworked API documentation to be compatible with readthedocs.org. Published to http://jasy.readthedocs.org/en/latest/
- Improved session cleanup logic so if you ever wondered about caching issues for generated virtual files or locales these should be gone now. Cleaning now removes generated/virtual classes as well. No worry: These will be automatically re-generated when needed.
- Added new `jasy.version` field into each build to have client side access to the version of Jasy used during the build.
- Added `executeCommand` to the `jasyscript.py` environment automatically.
- Added support for "not" type handling in `DeadCode` elimination for JavaScript.
- Added asset handling support for JPEG-XR and WEBP image formats

Fixes/Cleanups:

- Fixed HTTP server support for WOFF fonts to send the correct mime type
- Some internal optimizations for importing own modules making code cleaner and more robust
- Removed pretty useless "context" info when generating/processing AST trees and simplified code in `ClassItem`.
- Prefixed all cache items in `ClassItem` and `StyleItem` with either "script" or "style" to prevent conflicts between same IDs between these types.
- Removed "size" info (about compressed/permutated file size) from `ClassItem` and API data
- Cleanup of hoisting code in JavaScript parser. This was some old code from Narcissus and was never actually used because of the `ScopeAnalyzer` in Jasy which does somewhat the same and is also used during tree updates during the different optimization steps.
- Cleanup of `save()` and `rewind()` of the JavaScript `Tokenizer` which were never actually used.