2110

pending completion

Build # 2110

Build Type

Pull #1294

travis-ci

Committed by

web-flow

Commit Message

<a href="https://github.com/cucumber/cucumber-jvm/commit/<a class=hub.com/cucumber/cucumber-jvm/commit/53a13c673c0b749639492e805d20d4cbdf528d2f">53a13c673<a href="https://github.com/cucumber/cucumber-jvm/commit/53a13c673c0b749639492e805d20d4cbdf528d2f">&quot;&gt;Revert &amp;quot;[Core] Remove the deprecated -f/--format option. (#1260)&quot;

This reverts commit </a><a class="double-link" href="https://github.com/cucumber/cucumber-jvm/commit/<a class="double-link" href="https://github.com/cucumber/cucumber-jvm/commit/9a0ed2b9814884c9e49ed7ee03a7a10e36877af3">9a0ed2b98</a>">9a0ed2b98</a><a href="https://github.com/cucumber/cucumber-jvm/commit/53a13c673c0b749639492e805d20d4cbdf528d2f">.

Pull Request Pull Request #1294: Revert "Remove the deprecated -f/--format option"

Run Details

4 of 4 new or added lines in 2 files covered. (100.0%)

4893 of 6007 relevant lines covered (81.45%)

99.02 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

76.12

/core/src/main/java/cucumber/runtime/RuntimeOptions.java

package cucumber.runtime;

import cucumber.api.Plugin;
import cucumber.api.SnippetType;
import cucumber.api.StepDefinitionReporter;
import cucumber.api.SummaryPrinter;
import cucumber.api.event.TestRunStarted;
import cucumber.api.formatter.ColorAware;
import cucumber.api.formatter.Formatter;
import cucumber.api.formatter.StrictAware;
import cucumber.runner.EventBus;
import cucumber.deps.com.thoughtworks.xstream.annotations.XStreamConverter;
import cucumber.runtime.formatter.PluginFactory;
import cucumber.runtime.io.ResourceLoader;
import cucumber.runtime.model.CucumberFeature;
import cucumber.runtime.model.PathWithLines;
import cucumber.runtime.table.TablePrinter;
import cucumber.util.FixJava;
import cucumber.util.Mapper;
import gherkin.GherkinDialect;
import gherkin.GherkinDialectProvider;
import gherkin.IGherkinDialectProvider;

import java.io.InputStreamReader;
import java.io.Reader;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.ResourceBundle;
import java.util.regex.Pattern;

import static cucumber.runtime.model.CucumberFeature.load;
import static cucumber.util.FixJava.join;
import static cucumber.util.FixJava.map;
import static java.util.Arrays.asList;
import static java.util.Collections.unmodifiableList;

// IMPORTANT! Make sure USAGE.txt is always uptodate if this class changes.
public class RuntimeOptions {
    public static final String VERSION = ResourceBundle.getBundle("cucumber.version").getString("cucumber-jvm.version");
    public static final String USAGE_RESOURCE = "/cucumber/api/cli/USAGE.txt";

    static String usageText;

    private static final Mapper<String, String> QUOTE_MAPPER = new Mapper<String, String>() {
        @Override
        public String map(String o) {
            return '"' + o + '"';
        }
    };
    private static final Mapper<String, String> CODE_KEYWORD_MAPPER = new Mapper<String, String>() {
        @Override
        public String map(String keyword) {
            return keyword.replaceAll("[\\s',!]", "");
        }
    };

    private final List<String> glue = new ArrayList<String>();
    private final List<String> tagFilters = new ArrayList<String>();
    private final List<Pattern> nameFilters = new ArrayList<Pattern>();
    private final Map<String, List<Long>> lineFilters = new HashMap<String, List<Long>>();
    private final List<String> featurePaths = new ArrayList<String>();
    private final List<String> pluginFormatterNames = new ArrayList<String>();
    private final List<String> pluginStepDefinitionReporterNames = new ArrayList<String>();
    private final List<String> pluginSummaryPrinterNames = new ArrayList<String>();
    private final List<String> junitOptions = new ArrayList<String>();
    private final PluginFactory pluginFactory;
    private final List<Plugin> plugins = new ArrayList<Plugin>();
    private final List<XStreamConverter> converters = new ArrayList<XStreamConverter>();
    private boolean dryRun;
    private boolean strict = false;
    private boolean monochrome = false;
    private SnippetType snippetType = SnippetType.UNDERSCORE;
    private boolean pluginNamesInstantiated;
    private EventBus bus;

    /**
     * Create a new instance from a string of options, for example:
     * <p/>
     * <pre<{@code "--name 'the fox' --plugin pretty --strict"}</pre>
     *
     * @param argv the arguments
     */
    public RuntimeOptions(String argv) {
        this(new PluginFactory(), Shellwords.parse(argv));
    }

    /**
     * Create a new instance from a list of options, for example:
     * <p/>
     * <pre<{@code Arrays.asList("--name", "the fox", "--plugin", "pretty", "--strict");}</pre>
     *
     * @param argv the arguments
     */
    public RuntimeOptions(List<String> argv) {
        this(new PluginFactory(), argv);
    }

    public RuntimeOptions(Env env, List<String> argv) {
        this(env, new PluginFactory(), argv);
    }

    public RuntimeOptions(PluginFactory pluginFactory, List<String> argv) {
        this(Env.INSTANCE, pluginFactory, argv);
    }

    public RuntimeOptions(Env env, PluginFactory pluginFactory, List<String> argv) {
        this.pluginFactory = pluginFactory;

        argv = new ArrayList<String>(argv); // in case the one passed in is unmodifiable.
        parse(argv);

        String cucumberOptionsFromEnv = env.get("cucumber.options");
        if (cucumberOptionsFromEnv != null) {
            parse(Shellwords.parse(cucumberOptionsFromEnv));
        }

        if (pluginFormatterNames.isEmpty()) {
            pluginFormatterNames.add("progress");
        }
        if (pluginSummaryPrinterNames.isEmpty()) {
            pluginSummaryPrinterNames.add("default_summary");
        }
    }

    private void parse(List<String> args) {
        List<String> parsedTagFilters = new ArrayList<String>();
        List<Pattern> parsedNameFilters = new ArrayList<Pattern>();
        Map<String, List<Long>> parsedLineFilters = new HashMap<String, List<Long>>();
        List<String> parsedFeaturePaths = new ArrayList<String>();
        List<String> parsedGlue = new ArrayList<String>();
        ParsedPluginData parsedPluginData = new ParsedPluginData();
        List<String> parsedJunitOptions = new ArrayList<String>();

        while (!args.isEmpty()) {
            String arg = args.remove(0).trim();

            if (arg.equals("--help") || arg.equals("-h")) {
                printUsage();
                System.exit(0);
            } else if (arg.equals("--version") || arg.equals("-v")) {
                System.out.println(VERSION);
                System.exit(0);
            } else if (arg.equals("--i18n")) {
                String nextArg = args.remove(0);
                System.exit(printI18n(nextArg));
            } else if (arg.equals("--glue") || arg.equals("-g")) {
                String gluePath = args.remove(0);
                parsedGlue.add(gluePath);
            } else if (arg.equals("--tags") || arg.equals("-t")) {
                parsedTagFilters.add(args.remove(0));
            } else if (arg.equals("--plugin") || arg.equals("--add-plugin") || arg.equals("-p")) {
                parsedPluginData.addPluginName(args.remove(0), arg.equals("--add-plugin"));
            } else if (arg.equals("--format") || arg.equals("-f")) {
                System.err.println("WARNING: Cucumber-JVM's --format option is deprecated. Please use --plugin instead.");
                parsedPluginData.addPluginName(args.remove(0), true);
            } else if (arg.equals("--no-dry-run") || arg.equals("--dry-run") || arg.equals("-d")) {
                dryRun = !arg.startsWith("--no-");
            } else if (arg.equals("--no-strict") || arg.equals("--strict") || arg.equals("-s")) {
                strict = !arg.startsWith("--no-");
            } else if (arg.equals("--no-monochrome") || arg.equals("--monochrome") || arg.equals("-m")) {
                monochrome = !arg.startsWith("--no-");
            } else if (arg.equals("--snippets")) {
                String nextArg = args.remove(0);
                snippetType = SnippetType.fromString(nextArg);
            } else if (arg.equals("--name") || arg.equals("-n")) {
                String nextArg = args.remove(0);
                Pattern patternFilter = Pattern.compile(nextArg);
                parsedNameFilters.add(patternFilter);
            } else if (arg.startsWith("--junit,")) {
                for (String option : arg.substring("--junit,".length()).split(",")) {
                    parsedJunitOptions.add(option);
                }
            } else if (arg.startsWith("-")) {
                printUsage();
                throw new CucumberException("Unknown option: " + arg);
            } else {
                PathWithLines pathWithLines = new PathWithLines(arg);
                parsedFeaturePaths.add(pathWithLines.path);
                if (!pathWithLines.lines.isEmpty()) {
                    String key = pathWithLines.path.replace("classpath:", "");
                    addLineFilters(parsedLineFilters, key, pathWithLines.lines);
                }
            }
        }
        if (!parsedTagFilters.isEmpty() || !parsedNameFilters.isEmpty() || !parsedLineFilters.isEmpty() || haveLineFilters(parsedFeaturePaths)) {
            tagFilters.clear();
            tagFilters.addAll(parsedTagFilters);
            nameFilters.clear();
            nameFilters.addAll(parsedNameFilters);
            lineFilters.clear();
            for (String path : parsedLineFilters.keySet()) {
                lineFilters.put(path, parsedLineFilters.get(path));
            }
        }
        if (!parsedFeaturePaths.isEmpty()) {
            featurePaths.clear();
            featurePaths.addAll(parsedFeaturePaths);
        }

        if (!parsedGlue.isEmpty()) {
            glue.clear();
            glue.addAll(parsedGlue);
        }
        if (!parsedJunitOptions.isEmpty()) {
            junitOptions.clear();
            junitOptions.addAll(parsedJunitOptions);
        }

        parsedPluginData.updatePluginFormatterNames(pluginFormatterNames);
        parsedPluginData.updatePluginStepDefinitionReporterNames(pluginStepDefinitionReporterNames);
        parsedPluginData.updatePluginSummaryPrinterNames(pluginSummaryPrinterNames);
    }

    RuntimeOptions withConverters(List<XStreamConverter> converters) {
        this.converters.addAll(converters);
        return this;
    }

    private void addLineFilters(Map<String, List<Long>> parsedLineFilters, String key, List<Long> lines) {
        if (parsedLineFilters.containsKey(key)) {
            parsedLineFilters.get(key).addAll(lines);
        } else {
            parsedLineFilters.put(key, lines);
        }
    }

    private boolean haveLineFilters(List<String> parsedFeaturePaths) {
        for (String pathName : parsedFeaturePaths) {
            if (pathName.startsWith("@") || PathWithLines.hasLineFilters(pathName)) {
                return true;
            }
        }
        return false;
    }

    private void printUsage() {
        loadUsageTextIfNeeded();
        System.out.println(usageText);
    }

    static void loadUsageTextIfNeeded() {
        if (usageText == null) {
            try {
                Reader reader = new InputStreamReader(FixJava.class.getResourceAsStream(USAGE_RESOURCE), "UTF-8");
                usageText = FixJava.readReader(reader);
            } catch (Exception e) {
                usageText = "Could not load usage text: " + e.toString();
            }
        }
    }

    private int printI18n(String language) {
        IGherkinDialectProvider dialectProvider = new GherkinDialectProvider();
        List<String> languages = dialectProvider.getLanguages();

        if (language.equalsIgnoreCase("help")) {
            for (String code : languages) {
                System.out.println(code);
            }
            return 0;
        }
        if (languages.contains(language)) {
            return printKeywordsFor(dialectProvider.getDialect(language, null));
        }

        System.err.println("Unrecognised ISO language code");
        return 1;
    }

    private int printKeywordsFor(GherkinDialect dialect) {
        StringBuilder builder = new StringBuilder();
        TablePrinter printer = new TablePrinter();
        List<List<String>> table = new ArrayList<List<String>>();
        addKeywordRow(table, "feature", dialect.getFeatureKeywords());
        addKeywordRow(table, "background", dialect.getBackgroundKeywords());
        addKeywordRow(table, "scenario", dialect.getScenarioKeywords());
        addKeywordRow(table, "scenario outline", dialect.getScenarioOutlineKeywords());
        addKeywordRow(table, "examples", dialect.getExamplesKeywords());
        addKeywordRow(table, "given", dialect.getGivenKeywords());
        addKeywordRow(table, "when", dialect.getWhenKeywords());
        addKeywordRow(table, "then", dialect.getThenKeywords());
        addKeywordRow(table, "and", dialect.getAndKeywords());
        addKeywordRow(table, "but", dialect.getButKeywords());
        addCodeKeywordRow(table, "given", dialect.getGivenKeywords());
        addCodeKeywordRow(table, "when", dialect.getWhenKeywords());
        addCodeKeywordRow(table, "then", dialect.getThenKeywords());
        addCodeKeywordRow(table, "and", dialect.getAndKeywords());
        addCodeKeywordRow(table, "but", dialect.getButKeywords());
        printer.printTable(table, builder);
        System.out.println(builder.toString());
        return 0;
    }

    private void addCodeKeywordRow(List<List<String>> table, String key, List<String> keywords) {
        List<String> codeKeywordList = new ArrayList<String>(keywords);
        codeKeywordList.remove("* ");
        addKeywordRow(table, key + " (code)", map(codeKeywordList, CODE_KEYWORD_MAPPER));
    }

    private void addKeywordRow(List<List<String>> table, String key, List<String> keywords) {
        List<String> cells = asList(key, join(map(keywords, QUOTE_MAPPER), ", "));
        table.add(cells);
    }

    public List<CucumberFeature> cucumberFeatures(ResourceLoader resourceLoader, EventBus bus) {
        List<CucumberFeature> features = load(resourceLoader, featurePaths, System.out);
        getPlugins(); // to create the formatter objects
        bus.send(new TestRunStarted(bus.getTime()));
        for (CucumberFeature feature : features) {
            feature.sendTestSourceRead(bus);
        }
        return features;
    }

    public List<Plugin> getPlugins() {
        if (!pluginNamesInstantiated) {
            for (String pluginName : pluginFormatterNames) {
                Plugin plugin = pluginFactory.create(pluginName);
                plugins.add(plugin);
                setMonochromeOnColorAwarePlugins(plugin);
                setStrictOnStrictAwarePlugins(plugin);
                setEventBusFormatterPlugins(plugin);
            }
            for (String pluginName : pluginStepDefinitionReporterNames) {
                Plugin plugin = pluginFactory.create(pluginName);
                plugins.add(plugin);
            }
            for (String pluginName : pluginSummaryPrinterNames) {
                Plugin plugin = pluginFactory.create(pluginName);
                plugins.add(plugin);
            }
            pluginNamesInstantiated = true;
        }
        return plugins;
    }

    List<XStreamConverter> getConverters() {
        return unmodifiableList(converters);
    }

    public Formatter formatter(ClassLoader classLoader) {
        return pluginProxy(classLoader, Formatter.class);
    }

    public StepDefinitionReporter stepDefinitionReporter(ClassLoader classLoader) {
        return pluginProxy(classLoader, StepDefinitionReporter.class);
    }

    public SummaryPrinter summaryPrinter(ClassLoader classLoader) {
        return pluginProxy(classLoader, SummaryPrinter.class);
    }

    /**
     * Creates a dynamic proxy that multiplexes method invocations to all plugins of the same type.
     *
     * @param classLoader used to create the proxy
     * @param type        proxy type
     * @param <T>         generic proxy type
     * @return a proxy
     */
    private <T> T pluginProxy(ClassLoader classLoader, final Class<T> type) {
        Object proxy = Proxy.newProxyInstance(classLoader, new Class<?>[]{type}, new InvocationHandler() {
            @Override
            public Object invoke(Object target, Method method, Object[] args) throws Throwable {
                for (Object plugin : getPlugins()) {
                    if (type.isInstance(plugin)) {
                        try {
                            Utils.invoke(plugin, method, 0, args);
                        } catch (Throwable t) {
                            if (!method.getName().equals("startOfScenarioLifeCycle") && !method.getName().equals("endOfScenarioLifeCycle")) {
                                // IntelliJ has its own formatter which doesn't yet implement these methods.
                                throw t;
                            }
                        }
                    }
                }
                return null;
            }
        });
        return type.cast(proxy);
    }

    private void setMonochromeOnColorAwarePlugins(Object plugin) {
        if (plugin instanceof ColorAware) {
            ColorAware colorAware = (ColorAware) plugin;
            colorAware.setMonochrome(monochrome);
        }
    }

    private void setStrictOnStrictAwarePlugins(Object plugin) {
        if (plugin instanceof StrictAware) {
            StrictAware strictAware = (StrictAware) plugin;
            strictAware.setStrict(strict);
        }
    }

    private void setEventBusFormatterPlugins(Object plugin) {
        if (plugin instanceof Formatter && bus != null) {
            Formatter formatter = (Formatter) plugin;
            formatter.setEventPublisher(bus);
        }
    }

    public List<String> getGlue() {
        return glue;
    }

    public boolean isStrict() {
        return strict;
    }

    public boolean isDryRun() {
        return dryRun;
    }

    public List<String> getFeaturePaths() {
        return featurePaths;
    }

    public void addPlugin(Formatter plugin) {
        plugins.add(plugin);
        setEventBusFormatterPlugins(plugin);
    }

    public List<Pattern> getNameFilters() {
        return nameFilters;
    }

    public List<String> getTagFilters() {
        return tagFilters;
    }

    public Map<String, List<Long>> getLineFilters(ResourceLoader resourceLoader) {
        processRerunFiles(resourceLoader);
        return lineFilters;
    }

    private void processRerunFiles(ResourceLoader resourceLoader) {
        for (String featurePath : featurePaths) {
            if (featurePath.startsWith("@")) {
                for (PathWithLines pathWithLines : CucumberFeature.loadRerunFile(resourceLoader, featurePath.substring(1))) {
                    addLineFilters(lineFilters, pathWithLines.path, pathWithLines.lines);
                }
            }
        }
    }

    public boolean isMonochrome() {
        return monochrome;
    }

    public SnippetType getSnippetType() {
        return snippetType;
    }

    public List<String> getJunitOptions() {
        return junitOptions;
    }

    class ParsedPluginData {
        ParsedOptionNames formatterNames = new ParsedOptionNames();
        ParsedOptionNames stepDefinitionReporterNames = new ParsedOptionNames();
        ParsedOptionNames summaryPrinterNames = new ParsedOptionNames();

        public void addPluginName(String name, boolean isAddPlugin) {
            if (PluginFactory.isFormatterName(name)) {
                formatterNames.addName(name, isAddPlugin);
            } else if (PluginFactory.isStepDefinitionReporterName(name)) {
                stepDefinitionReporterNames.addName(name, isAddPlugin);
            } else if (PluginFactory.isSummaryPrinterName(name)) {
                summaryPrinterNames.addName(name, isAddPlugin);
            } else {
                throw new CucumberException("Unrecognized plugin: " + name);
            }
        }

        public void updatePluginFormatterNames(List<String> pluginFormatterNames) {
            formatterNames.updateNameList(pluginFormatterNames);
        }

        public void updatePluginStepDefinitionReporterNames(List<String> pluginStepDefinitionReporterNames) {
            stepDefinitionReporterNames.updateNameList(pluginStepDefinitionReporterNames);
        }

        public void updatePluginSummaryPrinterNames(List<String> pluginSummaryPrinterNames) {
            summaryPrinterNames.updateNameList(pluginSummaryPrinterNames);
        }
    }

    class ParsedOptionNames {
        private List<String> names = new ArrayList<String>();
        private boolean clobber = false;

        public void addName(String name, boolean isAddOption) {
            names.add(name);
            if (!isAddOption) {
                clobber = true;
            }
        }

        public void updateNameList(List<String> nameList) {
            if (!names.isEmpty()) {
                if (clobber) {
                    nameList.clear();
                }
                nameList.addAll(names);
            }
        }
    }

    void setEventBus(EventBus bus) {
        this.bus = bus;
    }
}

1	package cucumber.runtime;
2
3	import cucumber.api.Plugin;
4	import cucumber.api.SnippetType;
5	import cucumber.api.StepDefinitionReporter;
6	import cucumber.api.SummaryPrinter;
7	import cucumber.api.event.TestRunStarted;
8	import cucumber.api.formatter.ColorAware;
9	import cucumber.api.formatter.Formatter;
10	import cucumber.api.formatter.StrictAware;
11	import cucumber.runner.EventBus;
12	import cucumber.deps.com.thoughtworks.xstream.annotations.XStreamConverter;
13	import cucumber.runtime.formatter.PluginFactory;
14	import cucumber.runtime.io.ResourceLoader;
15	import cucumber.runtime.model.CucumberFeature;
16	import cucumber.runtime.model.PathWithLines;
17	import cucumber.runtime.table.TablePrinter;
18	import cucumber.util.FixJava;
19	import cucumber.util.Mapper;
20	import gherkin.GherkinDialect;
21	import gherkin.GherkinDialectProvider;
22	import gherkin.IGherkinDialectProvider;
23
24	import java.io.InputStreamReader;
25	import java.io.Reader;
26	import java.lang.reflect.InvocationHandler;
27	import java.lang.reflect.Method;
28	import java.lang.reflect.Proxy;
29	import java.util.ArrayList;
30	import java.util.HashMap;
31	import java.util.List;
32	import java.util.Map;
33	import java.util.ResourceBundle;
34	import java.util.regex.Pattern;
35
36	import static cucumber.runtime.model.CucumberFeature.load;
37	import static cucumber.util.FixJava.join;
38	import static cucumber.util.FixJava.map;
39	import static java.util.Arrays.asList;
40	import static java.util.Collections.unmodifiableList;
41
42	// IMPORTANT! Make sure USAGE.txt is always uptodate if this class changes.
43	public class RuntimeOptions {
44	public static final String VERSION = ResourceBundle.getBundle("cucumber.version").getString("cucumber-jvm.version");	2✔
45	public static final String USAGE_RESOURCE = "/cucumber/api/cli/USAGE.txt";
46
47	static String usageText;
48
49	private static final Mapper<String, String> QUOTE_MAPPER = new Mapper<String, String>() {	2✔
50	@Override
51	public String map(String o) {
52	return '"' + o + '"';	×
53	}
54	};
55	private static final Mapper<String, String> CODE_KEYWORD_MAPPER = new Mapper<String, String>() {	2✔
56	@Override
57	public String map(String keyword) {
58	return keyword.replaceAll("[\\s',!]", "");	×
59	}
60	};
61
62	private final List<String> glue = new ArrayList<String>();	336✔
63	private final List<String> tagFilters = new ArrayList<String>();	336✔
64	private final List<Pattern> nameFilters = new ArrayList<Pattern>();	336✔
65	private final Map<String, List<Long>> lineFilters = new HashMap<String, List<Long>>();	336✔
66	private final List<String> featurePaths = new ArrayList<String>();	336✔
67	private final List<String> pluginFormatterNames = new ArrayList<String>();	336✔
68	private final List<String> pluginStepDefinitionReporterNames = new ArrayList<String>();	336✔
69	private final List<String> pluginSummaryPrinterNames = new ArrayList<String>();	336✔
70	private final List<String> junitOptions = new ArrayList<String>();	336✔
71	private final PluginFactory pluginFactory;
72	private final List<Plugin> plugins = new ArrayList<Plugin>();	336✔
73	private final List<XStreamConverter> converters = new ArrayList<XStreamConverter>();	336✔
74	private boolean dryRun;
75	private boolean strict = false;	336✔
76	private boolean monochrome = false;	336✔
77	private SnippetType snippetType = SnippetType.UNDERSCORE;	336✔
78	private boolean pluginNamesInstantiated;
79	private EventBus bus;
80
81	/**
82	* Create a new instance from a string of options, for example:
83	* <p/>
84	* <pre<{@code "--name 'the fox' --plugin pretty --strict"}</pre>
85	*
86	* @param argv the arguments
87	*/
88	public RuntimeOptions(String argv) {
89	this(new PluginFactory(), Shellwords.parse(argv));	184✔
90	}	184✔
91
92	/**
93	* Create a new instance from a list of options, for example:
94	* <p/>
95	* <pre<{@code Arrays.asList("--name", "the fox", "--plugin", "pretty", "--strict");}</pre>
96	*
97	* @param argv the arguments
98	*/
99	public RuntimeOptions(List<String> argv) {
100	this(new PluginFactory(), argv);	108✔
101	}	106✔
102
103	public RuntimeOptions(Env env, List<String> argv) {
104	this(env, new PluginFactory(), argv);	40✔
105	}	40✔
106
107	public RuntimeOptions(PluginFactory pluginFactory, List<String> argv) {
108	this(Env.INSTANCE, pluginFactory, argv);	292✔
109	}	290✔
110
111	public RuntimeOptions(Env env, PluginFactory pluginFactory, List<String> argv) {	336✔
112	this.pluginFactory = pluginFactory;	336✔
113
114	argv = new ArrayList<String>(argv); // in case the one passed in is unmodifiable.	336✔
115	parse(argv);	336✔
116
117	String cucumberOptionsFromEnv = env.get("cucumber.options");	334✔
118	if (cucumberOptionsFromEnv != null) {	334✔
119	parse(Shellwords.parse(cucumberOptionsFromEnv));	38✔
120	}
121
122	if (pluginFormatterNames.isEmpty()) {	334✔
123	pluginFormatterNames.add("progress");	102✔
124	}
125	if (pluginSummaryPrinterNames.isEmpty()) {	334✔
126	pluginSummaryPrinterNames.add("default_summary");	326✔
127	}
128	}	334✔
129
130	private void parse(List<String> args) {
131	List<String> parsedTagFilters = new ArrayList<String>();	374✔
132	List<Pattern> parsedNameFilters = new ArrayList<Pattern>();	374✔
133	Map<String, List<Long>> parsedLineFilters = new HashMap<String, List<Long>>();	374✔
134	List<String> parsedFeaturePaths = new ArrayList<String>();	374✔
135	List<String> parsedGlue = new ArrayList<String>();	374✔
136	ParsedPluginData parsedPluginData = new ParsedPluginData();	374✔
137	List<String> parsedJunitOptions = new ArrayList<String>();	374✔
138
139	while (!args.isEmpty()) {	922✔
140	String arg = args.remove(0).trim();	550✔
141
142	if (arg.equals("--help") \|\| arg.equals("-h")) {	550✔
143	printUsage();	×
144	System.exit(0);	×
145	} else if (arg.equals("--version") \|\| arg.equals("-v")) {	550✔
146	System.out.println(VERSION);	×
147	System.exit(0);	×
148	} else if (arg.equals("--i18n")) {	550✔
149	String nextArg = args.remove(0);	×
150	System.exit(printI18n(nextArg));	×
151	} else if (arg.equals("--glue") \|\| arg.equals("-g")) {	×
152	String gluePath = args.remove(0);	92✔
153	parsedGlue.add(gluePath);	92✔
154	} else if (arg.equals("--tags") \|\| arg.equals("-t")) {	92✔
155	parsedTagFilters.add(args.remove(0));	18✔
156	} else if (arg.equals("--plugin") \|\| arg.equals("--add-plugin") \|\| arg.equals("-p")) {	440✔
157	parsedPluginData.addPluginName(args.remove(0), arg.equals("--add-plugin"));	256✔
158	} else if (arg.equals("--format") \|\| arg.equals("-f")) {	184✔
159	System.err.println("WARNING: Cucumber-JVM's --format option is deprecated. Please use --plugin instead.");	×
160	parsedPluginData.addPluginName(args.remove(0), true);	×
161	} else if (arg.equals("--no-dry-run") \|\| arg.equals("--dry-run") \|\| arg.equals("-d")) {	184✔
162	dryRun = !arg.startsWith("--no-");	4✔
163	} else if (arg.equals("--no-strict") \|\| arg.equals("--strict") \|\| arg.equals("-s")) {	180✔
164	strict = !arg.startsWith("--no-");	28✔
165	} else if (arg.equals("--no-monochrome") \|\| arg.equals("--monochrome") \|\| arg.equals("-m")) {	152✔
166	monochrome = !arg.startsWith("--no-");	20✔
167	} else if (arg.equals("--snippets")) {	132✔
168	String nextArg = args.remove(0);	26✔
169	snippetType = SnippetType.fromString(nextArg);	26✔
170	} else if (arg.equals("--name") \|\| arg.equals("-n")) {	26✔
171	String nextArg = args.remove(0);	16✔
172	Pattern patternFilter = Pattern.compile(nextArg);	16✔
173	parsedNameFilters.add(patternFilter);	16✔
174	} else if (arg.startsWith("--junit,")) {	16✔
175	for (String option : arg.substring("--junit,".length()).split(",")) {	26✔
176	parsedJunitOptions.add(option);	14✔
177	}
178	} else if (arg.startsWith("-")) {	78✔
179	printUsage();	2✔
180	throw new CucumberException("Unknown option: " + arg);	2✔
181	} else {
182	PathWithLines pathWithLines = new PathWithLines(arg);	76✔
183	parsedFeaturePaths.add(pathWithLines.path);	76✔
184	if (!pathWithLines.lines.isEmpty()) {	76✔
185	String key = pathWithLines.path.replace("classpath:", "");	8✔
186	addLineFilters(parsedLineFilters, key, pathWithLines.lines);	8✔
187	}
188	}
189	}	548✔
190	if (!parsedTagFilters.isEmpty() \|\| !parsedNameFilters.isEmpty() \|\| !parsedLineFilters.isEmpty() \|\| haveLineFilters(parsedFeaturePaths)) {	372✔
191	tagFilters.clear();	36✔
192	tagFilters.addAll(parsedTagFilters);	36✔
193	nameFilters.clear();	36✔
194	nameFilters.addAll(parsedNameFilters);	36✔
195	lineFilters.clear();	36✔
196	for (String path : parsedLineFilters.keySet()) {	36✔
197	lineFilters.put(path, parsedLineFilters.get(path));	8✔
198	}	8✔
199	}
200	if (!parsedFeaturePaths.isEmpty()) {	372✔
201	featurePaths.clear();	68✔
202	featurePaths.addAll(parsedFeaturePaths);	68✔
203	}
204
205	if (!parsedGlue.isEmpty()) {	372✔
206	glue.clear();	92✔
207	glue.addAll(parsedGlue);	92✔
208	}
209	if (!parsedJunitOptions.isEmpty()) {	372✔
210	junitOptions.clear();	10✔
211	junitOptions.addAll(parsedJunitOptions);	10✔
212	}
213
214	parsedPluginData.updatePluginFormatterNames(pluginFormatterNames);	372✔
215	parsedPluginData.updatePluginStepDefinitionReporterNames(pluginStepDefinitionReporterNames);	372✔
216	parsedPluginData.updatePluginSummaryPrinterNames(pluginSummaryPrinterNames);	372✔
217	}	372✔
218
219	RuntimeOptions withConverters(List<XStreamConverter> converters) {
220	this.converters.addAll(converters);	30✔
221	return this;	30✔
222	}
223
224	private void addLineFilters(Map<String, List<Long>> parsedLineFilters, String key, List<Long> lines) {
225	if (parsedLineFilters.containsKey(key)) {	8✔
226	parsedLineFilters.get(key).addAll(lines);	×
227	} else {
228	parsedLineFilters.put(key, lines);	8✔
229	}
230	}	8✔
231
232	private boolean haveLineFilters(List<String> parsedFeaturePaths) {
233	for (String pathName : parsedFeaturePaths) {	338✔
234	if (pathName.startsWith("@") \|\| PathWithLines.hasLineFilters(pathName)) {	64✔
235	return true;	2✔
236	}
237	}	62✔
238	return false;	336✔
239	}
240
241	private void printUsage() {
242	loadUsageTextIfNeeded();	2✔
243	System.out.println(usageText);	2✔
244	}	2✔
245
246	static void loadUsageTextIfNeeded() {
247	if (usageText == null) {	4✔
248	try {
249	Reader reader = new InputStreamReader(FixJava.class.getResourceAsStream(USAGE_RESOURCE), "UTF-8");	2✔
250	usageText = FixJava.readReader(reader);	2✔
251	} catch (Exception e) {	×
252	usageText = "Could not load usage text: " + e.toString();	×
253	}	2✔
254	}
255	}	4✔
256
257	private int printI18n(String language) {
258	IGherkinDialectProvider dialectProvider = new GherkinDialectProvider();	×
259	List<String> languages = dialectProvider.getLanguages();	×
260
261	if (language.equalsIgnoreCase("help")) {	×
262	for (String code : languages) {	×
263	System.out.println(code);	×
264	}	×
265	return 0;	×
266	}
267	if (languages.contains(language)) {	×
268	return printKeywordsFor(dialectProvider.getDialect(language, null));	×
269	}
270
271	System.err.println("Unrecognised ISO language code");	×
272	return 1;	×
273	}
274
275	private int printKeywordsFor(GherkinDialect dialect) {
276	StringBuilder builder = new StringBuilder();	×
277	TablePrinter printer = new TablePrinter();	×
278	List<List<String>> table = new ArrayList<List<String>>();	×
279	addKeywordRow(table, "feature", dialect.getFeatureKeywords());	×
280	addKeywordRow(table, "background", dialect.getBackgroundKeywords());	×
281	addKeywordRow(table, "scenario", dialect.getScenarioKeywords());	×
282	addKeywordRow(table, "scenario outline", dialect.getScenarioOutlineKeywords());	×
283	addKeywordRow(table, "examples", dialect.getExamplesKeywords());	×
284	addKeywordRow(table, "given", dialect.getGivenKeywords());	×
285	addKeywordRow(table, "when", dialect.getWhenKeywords());	×
286	addKeywordRow(table, "then", dialect.getThenKeywords());	×
287	addKeywordRow(table, "and", dialect.getAndKeywords());	×
288	addKeywordRow(table, "but", dialect.getButKeywords());	×
289	addCodeKeywordRow(table, "given", dialect.getGivenKeywords());	×
290	addCodeKeywordRow(table, "when", dialect.getWhenKeywords());	×
291	addCodeKeywordRow(table, "then", dialect.getThenKeywords());	×
292	addCodeKeywordRow(table, "and", dialect.getAndKeywords());	×
293	addCodeKeywordRow(table, "but", dialect.getButKeywords());	×
294	printer.printTable(table, builder);	×
295	System.out.println(builder.toString());	×
296	return 0;	×
297	}
298
299	private void addCodeKeywordRow(List<List<String>> table, String key, List<String> keywords) {
300	List<String> codeKeywordList = new ArrayList<String>(keywords);	×
301	codeKeywordList.remove("* ");	×
302	addKeywordRow(table, key + " (code)", map(codeKeywordList, CODE_KEYWORD_MAPPER));	×
303	}	×
304
305	private void addKeywordRow(List<List<String>> table, String key, List<String> keywords) {
306	List<String> cells = asList(key, join(map(keywords, QUOTE_MAPPER), ", "));	×
307	table.add(cells);	×
308	}	×
309
310	public List<CucumberFeature> cucumberFeatures(ResourceLoader resourceLoader, EventBus bus) {
311	List<CucumberFeature> features = load(resourceLoader, featurePaths, System.out);	14✔
312	getPlugins(); // to create the formatter objects	14✔
313	bus.send(new TestRunStarted(bus.getTime()));	14✔
314	for (CucumberFeature feature : features) {	14✔
315	feature.sendTestSourceRead(bus);	10✔
316	}	10✔
317	return features;	14✔
318	}
319
320	public List<Plugin> getPlugins() {
321	if (!pluginNamesInstantiated) {	338✔
322	for (String pluginName : pluginFormatterNames) {	230✔
323	Plugin plugin = pluginFactory.create(pluginName);	234✔
324	plugins.add(plugin);	234✔
325	setMonochromeOnColorAwarePlugins(plugin);	234✔
326	setStrictOnStrictAwarePlugins(plugin);	234✔
327	setEventBusFormatterPlugins(plugin);	234✔
328	}	234✔
329	for (String pluginName : pluginStepDefinitionReporterNames) {	230✔
330	Plugin plugin = pluginFactory.create(pluginName);	6✔
331	plugins.add(plugin);	6✔
332	}	6✔
333	for (String pluginName : pluginSummaryPrinterNames) {	230✔
334	Plugin plugin = pluginFactory.create(pluginName);	232✔
335	plugins.add(plugin);	232✔
336	}	232✔
337	pluginNamesInstantiated = true;	230✔
338	}
339	return plugins;	338✔
340	}
341
342	List<XStreamConverter> getConverters() {
343	return unmodifiableList(converters);	68✔
344	}
345
346	public Formatter formatter(ClassLoader classLoader) {
347	return pluginProxy(classLoader, Formatter.class);	×
348	}
349
350	public StepDefinitionReporter stepDefinitionReporter(ClassLoader classLoader) {
351	return pluginProxy(classLoader, StepDefinitionReporter.class);	14✔
352	}
353
354	public SummaryPrinter summaryPrinter(ClassLoader classLoader) {
355	return pluginProxy(classLoader, SummaryPrinter.class);	14✔
356	}
357
358	/**
359	* Creates a dynamic proxy that multiplexes method invocations to all plugins of the same type.
360	*
361	* @param classLoader used to create the proxy
362	* @param type proxy type
363	* @param <T> generic proxy type
364	* @return a proxy
365	*/
366	private <T> T pluginProxy(ClassLoader classLoader, final Class<T> type) {
367	Object proxy = Proxy.newProxyInstance(classLoader, new Class<?>[]{type}, new InvocationHandler() {	28✔
368	@Override
369	public Object invoke(Object target, Method method, Object[] args) throws Throwable {
370	for (Object plugin : getPlugins()) {	16✔
371	if (type.isInstance(plugin)) {	36✔
372	try {
373	Utils.invoke(plugin, method, 0, args);	16✔
374	} catch (Throwable t) {	×
375	if (!method.getName().equals("startOfScenarioLifeCycle") && !method.getName().equals("endOfScenarioLifeCycle")) {	×
376	// IntelliJ has its own formatter which doesn't yet implement these methods.
377	throw t;	×
378	}
379	}	16✔
380	}
381	}	36✔
382	return null;	16✔
383	}
384	});
385	return type.cast(proxy);	28✔
386	}
387
388	private void setMonochromeOnColorAwarePlugins(Object plugin) {
389	if (plugin instanceof ColorAware) {	234✔
390	ColorAware colorAware = (ColorAware) plugin;	42✔
391	colorAware.setMonochrome(monochrome);	42✔
392	}
393	}	234✔
394
395	private void setStrictOnStrictAwarePlugins(Object plugin) {
396	if (plugin instanceof StrictAware) {	234✔
397	StrictAware strictAware = (StrictAware) plugin;	12✔
398	strictAware.setStrict(strict);	12✔
399	}
400	}	234✔
401
402	private void setEventBusFormatterPlugins(Object plugin) {
403	if (plugin instanceof Formatter && bus != null) {	234✔
404	Formatter formatter = (Formatter) plugin;	196✔
405	formatter.setEventPublisher(bus);	196✔
406	}
407	}	234✔
408
409	public List<String> getGlue() {
410	return glue;
411	}
412
413	public boolean isStrict() {
414	return strict;
415	}
416
417	public boolean isDryRun() {
418	return dryRun;
419	}
420
421	public List<String> getFeaturePaths() {
422	return featurePaths;
423	}
424
425	public void addPlugin(Formatter plugin) {
426	plugins.add(plugin);	×
427	setEventBusFormatterPlugins(plugin);	×
428	}	×
429
430	public List<Pattern> getNameFilters() {
431	return nameFilters;
432	}
433
434	public List<String> getTagFilters() {
435	return tagFilters;
436	}
437
438	public Map<String, List<Long>> getLineFilters(ResourceLoader resourceLoader) {
439	processRerunFiles(resourceLoader);	226✔
440	return lineFilters;	226✔
441	}
442
443	private void processRerunFiles(ResourceLoader resourceLoader) {
444	for (String featurePath : featurePaths) {	226✔
445	if (featurePath.startsWith("@")) {	14✔
446	for (PathWithLines pathWithLines : CucumberFeature.loadRerunFile(resourceLoader, featurePath.substring(1))) {	×
447	addLineFilters(lineFilters, pathWithLines.path, pathWithLines.lines);	×
448	}	×
449	}
450	}	14✔
451	}	226✔
452
453	public boolean isMonochrome() {
454	return monochrome;
455	}
456
457	public SnippetType getSnippetType() {
458	return snippetType;
459	}
460
461	public List<String> getJunitOptions() {
462	return junitOptions;
463	}
464
465	class ParsedPluginData {	374✔
466	ParsedOptionNames formatterNames = new ParsedOptionNames();	374✔
467	ParsedOptionNames stepDefinitionReporterNames = new ParsedOptionNames();	374✔
468	ParsedOptionNames summaryPrinterNames = new ParsedOptionNames();	374✔
469
470	public void addPluginName(String name, boolean isAddPlugin) {
471	if (PluginFactory.isFormatterName(name)) {	256✔
472	formatterNames.addName(name, isAddPlugin);	238✔
473	} else if (PluginFactory.isStepDefinitionReporterName(name)) {	18✔
474	stepDefinitionReporterNames.addName(name, isAddPlugin);	6✔
475	} else if (PluginFactory.isSummaryPrinterName(name)) {	12✔
476	summaryPrinterNames.addName(name, isAddPlugin);	12✔
477	} else {
478	throw new CucumberException("Unrecognized plugin: " + name);	×
479	}
480	}	256✔
481
482	public void updatePluginFormatterNames(List<String> pluginFormatterNames) {
483	formatterNames.updateNameList(pluginFormatterNames);	372✔
484	}	372✔
485
486	public void updatePluginStepDefinitionReporterNames(List<String> pluginStepDefinitionReporterNames) {
487	stepDefinitionReporterNames.updateNameList(pluginStepDefinitionReporterNames);	372✔
488	}	372✔
489
490	public void updatePluginSummaryPrinterNames(List<String> pluginSummaryPrinterNames) {
491	summaryPrinterNames.updateNameList(pluginSummaryPrinterNames);	372✔
492	}	372✔
493	}
494
495	class ParsedOptionNames {	1,122✔
496	private List<String> names = new ArrayList<String>();	1,122✔
497	private boolean clobber = false;	1,122✔
498
499	public void addName(String name, boolean isAddOption) {
500	names.add(name);	256✔
501	if (!isAddOption) {	256✔
502	clobber = true;	252✔
503	}
504	}	256✔
505
506	public void updateNameList(List<String> nameList) {
507	if (!names.isEmpty()) {	1,116✔
508	if (clobber) {	254✔
509	nameList.clear();	250✔
510	}
511	nameList.addAll(names);	254✔
512	}
513	}	1,116✔
514	}
515
516	void setEventBus(EventBus bus) {
517	this.bus = bus;
518	}
519	}

cucumber / cucumber-jvm / 2110

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous