mikosik / smooth-build Goto Github PK

Acceptance tests should use whole smooth-build release and test it as a black box. Data used by each test should be a whole project structure (build.smooth file, some source files, etc). Each test should assert that executing given smooth command in such project yields correct results. We need to assert error/success messages printed to console and artifacts produced by execution.

$ smooth xxx
Exception in thread "main" org.smoothbuild.airline.ParseArgumentsUnexpectedException: Found unexpected parameters: [xxx]
at org.smoothbuild.airline.Cli.validate(Cli.java:148)
at org.smoothbuild.airline.Cli.parse(Cli.java:116)
at org.smoothbuild.airline.Cli.parse(Cli.java:97)
at org.smoothbuild.Main.main(Main.java:21)

Ideally it should happen automatically - site's html/javascript should fetch tutorial.md from github and convert it to html. In that case 'master' branch should contain version of tutorial.md that is valid for latest smooth release. To make everything work this way, whole development should happen on separate 'dev' branch which should be merged to 'master' when new release is done.

Checked exceptions have to go.
http://misko.hevery.com/2009/09/16/checked-exceptions-i-love-you-but-you-have-to-go/

By default, smooth script in .smooth file assumes project's root directory is one where .smooth file is located.
Option to specify other directory explicitly would be useful.

Hash of each TaskWorker should be based on:

• native java method that implements its functionality
• hash of jar file that contains bytecode of that method's class

Currently different implementation of TaskWorker use different algorithm for calculating hash.

file() and files() functions are not cacheable - during each build run they can returned different value for same arguments.
However during single build run they will return always the same value for given arguments so results can be cached in scope of single build.

I need task that interfaces with jarjar library

Move convert functions to funcs.jar so their hashes are calculated the same way as hashes of other functions.

basic terms to describe:

• environment, machine, running machine
• artifact
• hash
• hash calculation - of basic type, compound type (structures)
• call
• function
• caching - in scope of single build, network access, forever
• module/package
• task, task input, task output
• expression (is there difference between expression and task?)

As separate plugin 'junit' function will contain content of junit.jar so it does not have to be added to smooth.jar

Fix all TODOs in code.
For those that cannot be quickly fixed create issue in github tracker.
Make github tracker the only point of truth for project problems/bugs.

Algorithm in DefinedFunctionsCreator.commonSuperType() method has hardcoded type hierarchy.
Smooth type hierarchy should be provided via some data structure so mentioned algorithm can be generic.

Currently hash of any Computation does not take into account:

• installed java jdk - for example zip() function uses jdk for zipping which might produce different results in different verions of jdk
• external binaries - for example in case of java() function it doesn't take into account 'java' binary nor files/binaries it uses during execution. Such dependencies can transitively reach almost any binary on current machine or even files on different machines - for example results of linux 'nslookup' binary depends on state external to running machine.

In practice it's impossible to deal with state external to running machine.

State of the environment can be probably hashed if solution similar to docker is used. Smooth could use hash of docker image/config files as a hash of environment. Still it needs to be investigated whether docker image/config files are fully deterministic or at least can be made deterministic. I suspect that docker config may simply call 'nslookup' and based on results perform different actions - this way one config file (with given hash) can generate different environments.

The other solution is to use hash of the whole hard-disk device that machine is booting from. Asusming it is the only hard disk that machine is using.

Describe:

• what is cryptographic hash, sha1, how it works for compound values
• artifact hash
• function hash
• expression hash ( == task hash ?)
• environment hash

Each Message extends RuntimeException so it contains stack trace.
Command line option is needed for printing such stack-trace along each Message.

Refactor Task executing code so BuildInterruptedException is no longer needed.

Bring back CachedSmoothTest from git history. It should use to-be-created function that returns different result upon each call to check whether caching works correctly.

Add JavaClassTree that encapsulates Map from binary class name to JavaFileObject representing java class file.

Improve CommandExecutor to collect sysout and syserr streams and add them to messages. Enums Message.STDOUT and Message.STDERR should be created.

This way they can reuse functionality for hash calculation and caching that is implemented for NativeFunctions

I would like to have possibility of merging two filesystem trees, so I can have jar file with both: binaries and source code inside.

Each smooth function should be implemented in java as public static java function.

The same should be done to variables of mentioned types.
This should help avoiding ambiguity when block of code deals with java and smooth concepts at the same time. For example java parameter of java method that represents smooth parameter of smooth functions. They can be named jParam and sParam respectively to avoid confusion.