"Comma-separated list of output logging level for scopes in the format of <scope>:<level>[,<scope>:<level>,...]. "+
			"Possible values for <level>: none, error, warn, info, debug")
	logCmd.PersistentFlags().StringVar(&stackTraceLevel, "stack-trace-level", stackTraceLevel,
		"Comma-separated list of stack trace level for scopes in the format of <scope>:<stack-trace-level>[,<scope>:<stack-trace-level>,...]. "+

      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>marmalade</groupId>
      <artifactId>marmalade-core</artifactId>
      <version>0.1</version>
      <type>jar</type>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>marmalade</groupId>
      <artifactId>marmalade-el-ognl</artifactId>
      <version>0.1</version>
      <type>jar</type>
      <scope>compile</scope>

     * @param hexCode
     * @param scope
     */
    public Name ( Configuration cfg, String name, int hexCode, String scope ) {
        this.config = cfg;
        if ( name.length() > 15 ) {
            name = name.substring(0, 15);
        }
        this.name = name.toUpperCase();
        this.hexCode = hexCode;
        this.scope = scope != null && scope.length() > 0 ? scope : cfg.getNetbiosScope();

    protected final MojoExecutionScope scope;

    public MojoExecutionScopeModule(MojoExecutionScope scope) {
        this.scope = scope;
    }

    @Override
    protected void configure() {
        bindScope(MojoExecutionScoped.class, scope);
        // bindScope(org.apache.maven.api.di.MojoExecutionScoped.class, scope);
        bind(MojoExecutionScope.class).toInstance(scope);
        bind(MavenProject.class)

            effectiveScope = null;
        } else if (Artifact.SCOPE_SYSTEM.equals(originalScope)) {
            // system scope come through unchanged...
            effectiveScope = Artifact.SCOPE_SYSTEM;
        } else if (Artifact.SCOPE_COMPILE.equals(originalScope) && Artifact.SCOPE_COMPILE.equals(inheritedScope)) {
            // added to retain compile scope. Remove if you want compile inherited as runtime

        Project prj = nonNull(project, "project");
        if (nonNull(scope, "scope") == ProjectScope.MAIN) {
            return prj.getBuild().getResources();
        } else if (scope == ProjectScope.TEST) {
            return prj.getBuild().getTestResources();
        } else {
            throw new IllegalArgumentException("Unsupported scope " + scope);
        }
    }

    @Override

    private Set<String> scopes;

    /**
     * Create a new filter with the specified scopes and their implied scopes enabled.
     *
     * @param scopes The scopes to enable, along with all implied scopes, may be {@code null}.
     */
    public CumulativeScopeArtifactFilter(Collection<String> scopes) {
        this.scopes = new HashSet<>();

        addScopes(scopes);
    }

    /**

        /* farthest = provided */
        checkScopeUpdate(Artifact.SCOPE_PROVIDED, Artifact.SCOPE_COMPILE, Artifact.SCOPE_COMPILE);
        checkScopeUpdate(Artifact.SCOPE_PROVIDED, Artifact.SCOPE_PROVIDED, Artifact.SCOPE_PROVIDED);
        checkScopeUpdate(Artifact.SCOPE_PROVIDED, Artifact.SCOPE_RUNTIME, Artifact.SCOPE_RUNTIME);

            Scope.TEST),
    /**
     * <code>test</code> resolution scope
     * = <code>compile</code> + <code>runtime</code> + <code>provided</code> + <code>test</code> + <code>test-runtime</code>
     * dependencies
     */
    TEST_RUNTIME(
            "test-runtime", Scope.EMPTY, Scope.COMPILE, Scope.RUNTIME, Scope.PROVIDED, Scope.TEST, Scope.TEST_RUNTIME);

    private static final Map<String, ResolutionScope> VALUES =

        return artifactScope == null ? ArtifactScopeEnum.DEFAULT_SCOPE : artifactScope;
    }

    public void setArtifactScope(ArtifactScopeEnum artifactScope) {
        this.artifactScope = artifactScope;
    }

    public void setScope(String scope) {
        this.artifactScope = scope == null ? ArtifactScopeEnum.DEFAULT_SCOPE : ArtifactScopeEnum.valueOf(scope);
    }

    public String getClassifier() {