Ordinarily I'd also check that the filename was not "-", or perhaps
get the absolute path, but in this case I know the filename. (Otherwise
this could result in a hung process as gpg waited for stdin.)
If the classpath is very long or the list of java files to compile is very
long, javac task will result in "Argument list too long" error.
This patch uses @argfiles [1] optinos to javac instead of commmand line
options.
[1] http://docs.oracle.com/javase/6/docs/technotes/tools/windows/javac.html
The dependencies for pomegranate were cleaned up as of pomegranate-0.0.8. We no longer need to exclude slf4j. (Hard to claim this is important; I just happened to notice that it was not needed.)
Fixes#978.
By adding an atom (to pop off used aliases to avoid recursive calls)
which contains :user :aliases from profiles, we can use those aliases
outside of project maps. Whenever looking up aliases, will check the
atom if we're not in a project.
When specifying :filespecs with `:type :path`, copy-to-jar will iterate
over all elements within the path if the path is a directory, and remove
the path from the front of the path when added as a JarEntry. This is an
issue if you specify a file, as the path will then just be an empty
string. This is solved by invoking the newly implemented dir-string and
remove the result of that instead of removing the path itself.
Add support for profiles.d within the user's Leiningen home directory. All .clj
files within LEIN_HOME/profiles.d will be treated as maps merged into the
original profiles.clj (if existing).
Erroneous .clj file inside profiles.d emits an error message and will be treated
as nil.
A profile defined multiple times will error and "crash" the loading of profiles,
such that profiles return nil.
The errors will only be emitted once for user-friendliness.
This commit handles three major bugs with the current way of redirecting input
from Leiningen to a sub-process:
- The redirection is never stopped. This means that typing on the keyboard after
a sub-process has finished will crash the thread redirecting data from *in* to
the sub-process' input stream, as it is closed.
- The redirection is buffered. This means that data intended to a subsequent
sub-process may be sent to this sub-process instead.
- The redirection blocks instead of busy waits. For the output streams, this is
perfectly fine and the recommended approach to avoid wasting cycles. However,
this has some issues when done to an input stream: If the sub-process finishes
while the thread block waiting for a character, we will be unable to stop the
thread before a character has been read. The consequence is that a character
originally intended to the subsequent sub-process will be given to the
previous process.
These issues are solved by reading one byte at a time, busy wait on data and
gracefully exit when the sub-process has ended (through a mutable
variable/atom).