zynga/jasy

[DEPRECATED] A powerful Python3 based Web Tooling Framework.

Please note: This project is deprecated at Zynga and is no longer maintained.

---

Jasy - Web Tooling Framework

Jasy is a powerful Python3-based tooling framework. It makes it easy to manage heavy web projects. Its main goal is to offer an API which could be used by developers to write their custom build/deployment scripts.

Installation

For details have a look at the official documentation.

Documentation

• Documentation
• API Reference

Feedback

• Star Jasy
• Report an issue

QuickStart

• Jasy Boilerplate Skeleton with QuickStart guide for beginners
• Core Skeleton: Lightweight skeleton for using Jasy, Core and Api Browser with a set of pre-defined tasks.

Related

• Core: Core Library for JavaScript projects. Ideal JS counterpart to Jasy.
• Api Browser: Web-based API Browser to render API data generated by Jasy.
• Jasy Compat: Showing how to integrate other JavaScript libraries into Jasy workflow
• Jasy Locale: Demonstrating locale and translation support in Jasy/Core.

Test Skeletons

• Jasy Skeleton: Test skeletons for Jasy using different "jasy create" aspects
• Jasy Top Level Skeleton: Demonstrating how a standalone skeleton might look like.

Authors

Jasy was initially developed by Sebastian Werner and is now continued as an official Zynga OpenSource project.

License

Copyright (c) 2011-2012 Zynga Inc. http://zynga.com/

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

jasy's Issues

Build task to integrate Kraken API

Interesting offer:
http://www.kraken.io/developers

Image Size is not correctly identified

The size of images exported from Photoshop 6.0 with "save as" will be identified with an incorrect size.
Save for Web and Devices works.

Correct size: 760x538
Jasy identifies: 160x113

https://www.dropbox.com/s/x8d2d2y5gr2gfyq/broken.jpg

Add support for code coverage tests

Like these esprima based tools:
https://github.com/coveraje/coveraje
https://github.com/itay/node-cover

CSS Processor should support placeholder selectors and extend like Sass-3.2

Described in detail here:
http://chriseppstein.github.com/blog/2012/08/23/sass-3-2-is-released/

Integrate source code formatting support

Might be based on Python JS Beautify:
https://github.com/einars/js-beautify

Optimization does not remove full unused var declaration

Using Optimization does not remove a full unused var declaration assigned to an Object literal.

Jasy version: 0.4.6

Source Example:

__render: function () {

    var dimensions = {
        width: 100,
        height: 100
    };

    // other code removed that never references local dimensions var.
},

Optimization result:

__render:function(){{width:100,height:100}};

Js error:
Uncaught SyntaxError: Unexpected Token :

jasyscript.py code:

optimization = Optimization("variables", "declarations", "blocks")
formatting = Formatting()

Unused object generates invalid JS code

Unused object which has a function in its properties generate invalid JS code.

The following code

core.Class("p.MyClass", {
    construct: function() {
        var obj = {
            method: function() {
                return "result";
            }
        };
   }
});

is compressed to the following code (beautified to make it readable).

core.Class("p.MyClass", {
    construct: function () {
        {
            method: function () {
                return "result"
            }
        }
    }
});

And this code causes an error saying "Uncaught SyntaxError: Unexpected token (".

I'm using the latest Jasy (f86953e), but it's reproducible on Jasy==0.4.6.

Note that the compressed output code is generated by storeCompressed function with the default optimazation options.

compressedCode = storeCompressed("build/app-%s.js" % permutation.getChecksum(), classes,
        permutation=permutation, bootCode="new p.MyClass();")

Support for dependency tracking of AMD-like modules

Integrate image manipulation methods

This library feels like a good candidate:
http://liquibits.bitbucket.org

jasy create --version requires a different format than other arguments

For some reason, the --version argument requires a different format than the --name and --origin arguments, making it confusing for users:

Doesn't work: --version refs/tags/0.0.4

Works:        --version=refs/tags/0.0.4

Compare to --origin path/to/my/repo

Support for dependency tracking of NPM-like modules

Implement alternative distribution for Mac OS: App Bundle/PkgInstaller

Could be helpful for non-homebrew / non-XCode users. Could ship binary components like Misaka easily.

• http://developer.apple.com/library/mac/#documentation/Darwin/Reference/ManPages/man1/hdiutil.1.html
• http://www.recital.com/index.php?option=com_content&view=article&id=108:howto-build-a-dmg-file-from-the-command-line-on-mac-os-x&catid=67:developers
• http://developer.apple.com/library/mac/#documentation/CoreFoundation/Conceptual/CFBundles/Introduction/Introduction.html

Add support for strict mode

Error messages during parsing could be useful.

Detect custom namespaces/extensions for dependencies

These are figured out by the API system but not yet used for dependency tracking. Currently each class is attached to exactly one exported symbol which is problematic for this kind of deps where one feature like string.trim just adds a few methods to another class.

Add support for YAML config files

See also:
https://twitter.com/#!/mitsuhiko/status/203437587032047617

Hash changes on every reload

The current implementation generates a new hash for every file on every reload: Game.js?r=1346659290651
Perfectly would only generate a new hash for a new build.

Installing Jasy 0.7.2 with pip-3.2 is missing required dependencies

When I install jasy 0.7.2 from pip-3.2, it does not install any required dependencies. It will report errors if the following are not installed:

• polib
• Pygments
• misaka

These should be automatically installed when I install jasy if I do not already have them installed. The build still works without polib but not without misaka and Pygments.

polib error:
"Polib is no installed. Polib is needed to extract translation text from PO files!"

Markdown error:
"Missing Markdown feature to convert comments to HTML."

Add support for linking to dependencies

Which means to shorten often used class names to local variables via the introduction of a new global closure. This could basically work for all final "require" classes which are loaded before each actual class.

Add support for OptiPNG sprite optimization

Like in Glue:
https://github.com/jorgebastida/glue/

Add support for JSON-H

Especially useful for API data right now.
https://github.com/WebReflection/JSONH

Add/Improve detailed documentation for fields/permutations

urlPrefix of CDN-Url's wrong

If you run asset.exportBuild(urlPrefix="https://example.com") the resulting url of core.io.Asset.toUri("test/test.png") is https:/example.com/test/test.png. Note that there is only one slash after https:. This is due to calling os.path.normpath in core/Project.py inside toRelativeUrl method.

You can work around if you give an urlPrefix of "//example.com".

Add capability to re-scan assets at runtime.

If I have tasks that generate new assets, I cannot use those assets unless I restart jasy since it parses assets during initialization. It would be convenient to add a way of re-scanning the assets at runtime to allow us to collapse tasks into a single task if we want to.

core.detect.Param not found

Field 'theme' uses unknown detection class core.detect.Param while including apibrowser.

Add flag to disable update of git repositories

When working without permanent internet connection it would be great to have a flag to disable git repository updates. This should also increase run time of jasy on big projects that have many external dependencies.

CamelCase not supported in jasy create

When I use the create command with a CamelCase project name, it fails.

>>> CREATING PROJECT TESTAPP
-------------------------------------------------------------------------------
Invalid project name: TestApp

Add support for sourcemaps

http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/

SourceMaps are remappings of generated code to source code.

Support CSS compression during deployment

Might require more CSS work in general.
https://github.com/GoalSmashers/clean-css

Add style sheet preprocessor (aka asset preprocessing)

This especially needs a solution of where to place the processed assets aka like the "script" folder for JavaScript classes.

Add support for pretty printing code

Based on a configuration of indents, etc. to use.

Integrate auto task execution on file system changes

e.g. via FSEvents on OS X:
http://pypi.python.org/pypi/MacFSEvents

Split wiki documentation into multiple documents

Maybe splitting into:

• Overview
• Project Configurations
  • Classes
  • Assets
    • Overriding assets
  • Custom Layouts (jQuery, qunit, etc.)
• Build Scripts
• Integration with Core library

Optimize deep copy of nodes

Class uses deep copy to copy a full tree fo a class before compressing it. Maybe we find a better/faster way copying nodes.

See also:
http://writeonly.wordpress.com/2009/05/07/deepcopy-is-a-pig-for-simple-data/

Support extra classes/dependencies for storeKernel()

Might be useful to have the possibility to force include classes into the kernel script.

For Dumb Developers, please provide a link in the Walkthrough on how to install pip-3.2

Took me about 20 minutes of googling to install pip-3.2 explicitly.

http://stackoverflow.com/questions/11268501/how-to-use-pip-with-python-3-x-besides-python-2-x

RegExp literal in array causes "jasy.js.parse.Parser.SyntaxError: Syntax error: Missing operand. Found type: div"

Jasy(both 0.4.6 and 0.5 beta2) seems to treat RegExp literals in an array as syntax error.

The following code,

core.Class("p.helloworld.App", {
    construct: function(settings) {
        var arr = [/pattern/];
    }
});

will output this error.

% ./jasyscript.py build
Jasy 0.5-beta2
Initialized project core
Initialized project p.helloworld
Detecting dependencies...
Traceback (most recent call last):
   File "/Users/csakatoku/.virtualenvs/jasy/bin/jasy", line 110, in <module>
   # skip...
  File "/Users/csakatoku/.virtualenvs/jasy/lib/python3.2/site-packages/jasy/js/parse/Parser.py", line 1311, in MultiplyExpression
    node = UnaryExpression(tokenizer, staticContext)
  File "/Users/csakatoku/.virtualenvs/jasy/lib/python3.2/site-packages/jasy/js/parse/Parser.py", line 1338, in UnaryExpression
    node = MemberExpression(tokenizer, staticContext, True)
  File "/Users/csakatoku/.virtualenvs/jasy/lib/python3.2/site-packages/jasy/js/parse/Parser.py", line 1367, in MemberExpression
    node = PrimaryExpression(tokenizer, staticContext)
  File "/Users/csakatoku/.virtualenvs/jasy/lib/python3.2/site-packages/jasy/js/parse/Parser.py", line 1535, in PrimaryExpression
    raise SyntaxError("Missing operand. Found type: %s" % tokenType, tokenizer)
jasy.js.parse.Parser.SyntaxError: Syntax error: Missing operand. Found type: div
p.helloworld.App:3
Closing session...

FYI, my jascript.py is here.

• https://gist.github.com/1787832

Support for reusing immutable string instances

String instances are generally expensive - even so they are immutable. It helps to move them in a class-global closure and share them via local variables. This should be implemented in a way that only often used strings etc. are shared that way or only for specifically marked strings.

Add easy AST processing feature like in Falafel

https://github.com/substack/node-falafel

Add hint support ala jshint

Depends on tokenizer and parser. Maybe the tree does not yet contain all necessary information.

documentation insufficient for new users

wiki provides a high level overview of jasy functionality, while code documentation is almost non-existent. Most functions/classes lack even one line docstrings.

Could use a lower level of documentation, such as specific examples of why/where we would use certain features. A small example project would be greatly appreciated.

Add support for ICU message format

The widely used alternative to PO/Gettext. There is a Python implementation available:
http://pyicu.osafoundation.org

Add support for wildcards in #require hints

Like #require(some.namespace.*)

Integrate CSS Min / JS Beautifier modules from ClientSide for Sublime

Especially the CSS minifier port to Python might be useful.
https://github.com/trentrichardson/Clientside

Root directory for the server

Current implementation uses the jasy root project also as root for the server.
Perfect would be something like "DocumentRoot" like it is used in Apache.

Add support for PNG8 output of sprite packer

And maybe other inspiration from Glue:
https://github.com/jorgebastida/glue/

Doc support for map constructs

/**

• @someParam
• @options {Map} A map with more options
• @options.port {Number} A number dong
• @options.host {String} A String thing
  */

You get the idea.

Add documentation for project handling/project dependencies

The new "requires" section as well as auto cloning etc. should be documented.

Integrate CSS Parser

This might be a good candidate:
http://packages.python.org/tinycss/index.html

Add method to inline CSS when copying html pages to the build folder

Currently, Jasy has no way of dealing with CSS linked from the head of a HTML page. When the index.html is copied to the build folder, the static paths do not resolve anymore.

I'm proposing to add a method that copies the index.html and stores it in optimized form, i.e.:

storeOptimizedPage("source/index.html", "index.html", inlineCSS=True);

This command would copy the index.html page to its destination (like updateFile), but also parse all linked stylesheets in the file and automatically embed them into the HTML page. It's a win win: Jasy learns how to resolve those paths, and the user gets less requests as bonus.

Add support for code linting for JavaScript

Using JSHint or custom implementation.