{namespace buck.clean}

/***/
{template .soyweb}
  {call buck.page}
    {param title: 'buck clean' /}
    {param content}

{call buck.command}
{param overview}
Deletes all files generated by Buck.

<p>

Buck keeps all of its deliverables and state in files, so deleting
those files is guaranteed to reset Buck's state so that a "clean
build" can be performed. The set of files where Buck stores its output
may change over time, but <code>buck clean</code> will always remove
the appropriate files for the current version.

{/param}

{param params}
{call buck.param}
  {param name: 'project' /}
  {param alias: 'p'/}
  {param desc}
  Delete the directories generated by <code>buck project</code>.
  This will not remove any <code>.iml</code> files, nor any files
  under <code>.idea</code> for IntelliJ.
  {/param}
{/call}

{call buck.param}
  {param name: 'verbose' /}
  {param alias: 'v'/}
  {param desc}
  How verbose logging to the console should be, with 1 as the minimum
  and 10 as the most verbose.
  {/param}
{/call}
{/param}

{/call}

    {/param}  // content
  {/call} // buck.page
{/template}
