lucid 0.0.4 → 0.0.5

data/lib/lucid/cli/options.rb

@@ -0,0 +1,463 @@
+require 'lucid/cli/profile'
+require 'lucid/formatter/ansicolor'
+require 'lucid/interface_rb/rb_language'
+
+module Lucid
+  module CLI
+    class Options
+
+      INDENT = ' ' * 53
+      LUCID_FORMATS = {
+        'html'        => ['Lucid::Formatter::Html',        'Generates an HTML report.'],
+        'standard'    => ['Lucid::Formatter::Standard',    'Prints the spec as-is, using color if available.'],
+        'progress'    => ['Lucid::Formatter::Progress',    'Prints one character per scenario.'],
+        'rerun'       => ['Lucid::Formatter::Rerun',       'Prints failing specs with line numbers.'],
+        'usage'       => ['Lucid::Formatter::Usage',       "Prints where test definitions are used.\n" +
+                                                              "#{INDENT}The slowest test definitions (with duration) are\n" +
+                                                              "#{INDENT}listed first. If --dry-run is used the duration\n" +
+                                                              "#{INDENT}is not shown, and test definitions are sorted by\n" +
+                                                              "#{INDENT}file name instead."],
+        'stepdefs'    => ['Lucid::Formatter::Stepdefs',    "Prints all test definitions with their locations. Same as\n" +
+                                                              "#{INDENT}the usage formatter, except that steps are not printed."],
+        'junit'       => ['Lucid::Formatter::Junit',       'Generates a report similar to Ant+JUnit.'],
+        'json'        => ['Lucid::Formatter::Json',        'Prints the spec as JSON.'],
+        'json_pretty' => ['Lucid::Formatter::JsonPretty',  'Prints the spec as prettified JSON.'],
+        'debug'       => ['Lucid::Formatter::Debug',       'Prints the calls made to the listeners.']
+      }
+      largest = LUCID_FORMATS.keys.map{|s| s.length}.max
+      FORMAT_LIST = (LUCID_FORMATS.keys.sort.map do |key|
+        "  #{key}#{' ' * (largest - key.length)} : #{LUCID_FORMATS[key][1]}"
+      end) + ["Use --format rerun --out specs.txt to write out failing",
+              "specs. You can rerun them with lucid @rerun.txt.",
+              "FORMAT can also be the fully qualified class name of",
+              "your own custom formatter. If the class isn't loaded,",
+              "Lucid will attempt to require a file with a relative",
+              "file name that is the underscore name of the class name.",
+              "  Example: --format Formatter::WordDoc",
+              "With that, Lucid will look for formatter/word_doc.rb",
+              "You can place the file with this relative path",
+              "underneath your common/support directory or anywhere",
+              "on Ruby's LOAD_PATH."
+      ]
+      PROFILE_SHORT_FLAG = '-p'
+      NO_PROFILE_SHORT_FLAG = '-P'
+      PROFILE_LONG_FLAG = '--profile'
+      NO_PROFILE_LONG_FLAG = '--no-profile'
+      OPTIONS_WITH_ARGS = ['-r', '--require', '--i18n', '-f', '--format', '-o', '--out',
+                           '-t', '--tags', '-n', '--name', '-e', '--exclude',
+                           PROFILE_SHORT_FLAG, PROFILE_LONG_FLAG,
+                           '-a', '--autoformat', '-l', '--lines', '--port',
+                           '-I', '--matcher-type']
+
+      def self.parse(args, out_stream, error_stream, options = {})
+        new(out_stream, error_stream, options).parse(args)
+      end
+
+      def initialize(out_stream = STDOUT, error_stream = STDERR, options = {})
+        @out_stream   = out_stream
+        @error_stream = error_stream
+
+        @default_profile = options[:default_profile]
+        @profiles = []
+        @overridden_paths = []
+        @options = default_options
+        @profile_loader = options[:profile_loader]
+        @options[:skip_profile_information] = options[:skip_profile_information]
+
+        @quiet = @disable_profile_loading = nil
+      end
+
+      def [](key)
+        @options[key]
+      end
+
+      def []=(key, value)
+        @options[key] = value
+      end
+
+      def parse(args)
+        @args = args
+        @expanded_args = @args.dup
+
+        @args.extend(::OptionParser::Arguable)
+
+        @args.options do |opts|
+          opts.banner = ["Lucid: Test Description Language Execution Engine",
+                         "Usage: lucid [options] [ [FILE|DIR|URL][:LINE[:LINE]*] ]+", "", ""
+          ].join("\n")
+
+          opts.on("--library-path PATH", "Location of spec project library files.") do |path|
+            @options[:library_path] = path
+          end
+
+          opts.on("--spec-type TYPE", "The file type (extension) for Lucid specifications.") do |type|
+            @options[:spec_type] = type
+          end
+
+          opts.separator ""
+
+          opts.on("-r LIBRARY|DIR", "--require LIBRARY|DIR",
+                  "Require files before executing the features. If this option",
+                  "is not specified, all *.rb files that are siblings or below",
+                  "the features will be loaded automatically. Automatic loading",
+                  "is disabled when this option is specified. That means all",
+                  "loading becomes explicit.",
+                  "Files under directories named \"support\" will always be",
+                  "loaded first.",
+                  "This option can be specified multiple times.") do |v|
+            @options[:require] << v
+            if(Lucid::JRUBY && File.directory?(v))
+              require 'java'
+              $CLASSPATH << v
+            end
+          end
+
+          opts.separator ""
+
+          opts.on("-f FORMAT", "--format FORMAT",
+                  "How Lucid will format spec execution output.",
+                  "(Default: standard). Available formats:",
+                  *FORMAT_LIST
+          ) do |v|
+            @options[:formats] << [v, @out_stream]
+          end
+
+          opts.on("-o", "--out [FILE|DIR]",
+                  "Write output to a file or directory instead of to standard",
+                  "console output. This option applies to any specified format",
+                  "option (via the --format switch) or to the default format",
+                  "if no format was specified. You can check the specific",
+                  "documentation for a given formatter to see whether to pass",
+                  "a file or a directory."
+          ) do |v|
+            @options[:formats] << ['standard', nil] if @options[:formats].empty?
+            @options[:formats][-1][1] = v
+          end
+
+          opts.separator ""
+
+          opts.on("-d", "--dry-run", "Invokes formatters without executing the steps.",
+                  "This also omits the loading of your support/env.rb file if it exists.") do
+            @options[:dry_run] = true
+          end
+
+          opts.on("-n NAME", "--name NAME",
+                  "Lucid will only execute features or abilities that match with the name",
+                  "provided. The match can be done on partial information. If this option",
+                  "is provided multiple times, then the match will be performed against",
+                  "each set of provided names."
+          ) do |v|
+            @options[:name_regexps] << /#{v}/
+          end
+
+          opts.on("-l", "--lines LINES", "Run given line numbers. Equivalent to FILE:LINE syntax") do |lines|
+            @options[:lines] = lines
+          end
+
+          opts.on("-e", "--exclude PATTERN",
+                  "Lucid will not use files that match the PATTERN.") do |v|
+            @options[:excludes] << Regexp.new(v)
+          end
+
+          opts.on("-t TAG_EXPRESSION", "--tags TAG_EXPRESSION",
+                  "Lucid will only execute features or scenarios with tags that match the",
+                  "tag expression provided. A single tag expressions can have several tags",
+                  "separated by a comma, which represents a logical OR. If this option is",
+                  "provided more than once, this represents a logical AND. A tag expression",
+                  "can be prefaced with a ~ character, which represents a logical NOT.",
+                  "Examples:",
+                  " --tags @smoke.",
+                  " --tags ~@wip",
+                  " --tags @smoke,@wip",
+                  " --tags @smoke,~@wip --tags @regression",
+                  "If you want to use multiple exclusion tags, you must use the logical",
+                  "AND approach, as in: --tags ~@wip --tags ~@failing",
+                  "Positive tags can be given a threshold to limit the number of occurrences.",
+                  "Example: --tags @critical:3",
+                  "That will fail if there are more than three occurrences of the @critical tag."
+          ) do |v|
+            @options[:tag_expressions] << v
+          end
+
+          opts.separator ""
+
+          opts.on(PROFILE_SHORT_FLAG, "#{PROFILE_LONG_FLAG} PROFILE",
+                  "Pull commandline arguments from lucid.yml which can be defined as",
+                  "strings or arrays. When a 'default' profile is defined and no profile",
+                  "is specified it is always used. (Unless disabled, see -P below.)",
+                  "When feature files are defined in a profile and on the command line",
+                  "then only the ones from the command line are used."
+          ) do |v|
+            @profiles << v
+          end
+
+          opts.on(NO_PROFILE_SHORT_FLAG, NO_PROFILE_LONG_FLAG,
+            "Disables all profile loading to avoid using the 'default' profile.") do |v|
+            @disable_profile_loading = true
+          end
+
+          opts.separator ""
+
+          opts.on("-c", "--[no-]color",
+                  "Specifies whether or not to use ANSI color in the output. If this",
+                  "option is not specified, Lucid makes the decision on colored output",
+                  "based on your platform and the output destination."
+          ) do |v|
+            Lucid::Term::ANSIColor.coloring = v
+          end
+
+          opts.on("-a", "--autoformat DIR",
+            "Reformats (pretty prints) spec files and write them to DIRECTORY.",
+            "Be careful if you choose to overwrite the originals.",
+            "Implies --dry-run --format pretty.") do |directory|
+            @options[:autoformat] = directory
+            Lucid::Term::ANSIColor.coloring = false
+            @options[:dry_run] = true
+            @quiet = true
+          end
+
+          opts.on("-m", "--no-multiline",
+                  "Lucid will not print multiline strings and tables under steps.") do
+            @options[:no_multiline] = true
+          end
+
+          opts.on("-s", "--no-source",
+                  "Lucid will not print the file and line of the test definition with the steps.") do
+            @options[:source] = false
+          end
+
+          opts.on("-i", "--no-matchers",
+                  "Lucid will not print matchers for pending steps.") do
+            @options[:matchers] = false
+          end
+
+          opts.on("-I", "--matchers-type TYPE",
+                  "Use different matcher type (Default: regexp).",
+                  "Available types:",
+                  *Lucid::InterfaceRb::RbLanguage.cli_matcher_type_options
+          ) do |v|
+            @options[:matcher_type] = v.to_sym
+          end
+
+          opts.on("-q", "--quiet", "Alias for --no-matchers --no-source.") do
+            @quiet = true
+          end
+
+          opts.on("-S", "--strict", "Fail if there are any undefined or pending steps.") do
+            @options[:strict] = true
+          end
+
+          opts.on("-w", "--wip", "Fail if there are any passing scenarios.") do
+            @options[:wip] = true
+          end
+
+          opts.on("-g", "--guess", "Guess best match for ambiguous steps.") do
+            @options[:guess] = true
+          end
+
+          opts.on("-x", "--expand", "Expand Scenario Outline tables in output.") do
+            @options[:expand] = true
+          end
+
+          opts.separator ""
+
+          opts.on("--testdefs DIR", "Lucid will Write test definition metadata to the DIR.") do |dir|
+            @options[:testdefs] = dir
+          end
+
+          if(Lucid::JRUBY)
+            opts.on("-j DIR", "--jars DIR",
+                    "Load all the jars under the specified directory.") do |jars|
+              Dir["#{jars}/**/*.jar"].each {|jar| require jar}
+            end
+          end
+
+          opts.on("--i18n LANG",
+                  "List keywords for a particular language.",
+                  %{Run with "--i18n help" to see all languages}) do |lang|
+            if lang == 'help'
+              list_languages_and_exit
+            else
+              list_keywords_and_exit(lang)
+            end
+          end
+
+          opts.separator ""
+
+          opts.on("-b", "--backtrace", "Show full backtrace for all errors during Lucid execution.") do
+            Lucid.use_full_backtrace = true
+          end
+
+          opts.on("-v", "--verbose", "Show detailed information about Lucid execution.") do
+            @options[:verbose] = true
+          end
+
+          opts.on("--debug", "Show behind-the-scenes information about Lucid execution.") do
+            @options[:debug] = true
+          end
+
+          opts.separator ""
+
+          opts.on_tail("--version", "Show Lucid version information.") do
+            @out_stream.puts Lucid::VERSION
+            Kernel.exit(0)
+          end
+
+          opts.on_tail("-h", "--help", "Show Lucid execution options.") do
+            @out_stream.puts opts.help
+            Kernel.exit(0)
+          end
+        end.parse!
+
+        if @quiet
+          @options[:matchers] = @options[:source] = false
+        else
+          @options[:matchers] = true if @options[:matchers].nil?
+          @options[:source]   = true if @options[:source].nil?
+        end
+        @args.map! { |a| "#{a}:#{@options[:lines]}" } if @options[:lines]
+
+        extract_environment_variables
+
+        # This line grabs whatever is left over on the command line. That
+        # would have to be the spec repo.
+        @options[:spec_source] = @args.dup
+
+        establish_profile
+
+        self
+      end
+
+      def custom_profiles
+        @profiles - [@default_profile]
+      end
+
+      # @see Lucid::CLI::Configuration.filters
+      def filters
+        @options.values_at(:name_regexps, :tag_expressions).select{|v| !v.empty?}.first || []
+      end
+
+    protected
+
+      attr_reader :options, :profiles, :expanded_args
+      protected :options, :profiles, :expanded_args
+
+    private
+
+      def non_stdout_formats
+        @options[:formats].select {|format, output| output != @out_stream }
+      end
+
+      def stdout_formats
+        @options[:formats].select {|format, output| output == @out_stream }
+      end
+
+      def extract_environment_variables
+        @args.delete_if do |arg|
+          if arg =~ /^(\w+)=(.*)$/
+            @options[:env_vars][$1] = $2
+            true
+          end
+        end
+      end
+
+      def disable_profile_loading?
+        @disable_profile_loading
+      end
+
+      def establish_profile
+        if @disable_profile_loading
+          @out_stream.puts "Disabling profiles..."
+          return
+        end
+
+        @profiles << @default_profile if using_default_profile?
+
+        @profiles.each do |profile|
+          merge_with_profile(profile)
+        end
+
+        @options[:profiles] = @profiles
+      end
+
+      def merge_with_profile(profile)
+        profile_args = profile_loader.args_from(profile)
+        profile_options = Options.parse(
+          profile_args, @out_stream, @error_stream,
+          :skip_profile_information => true,
+          :profile_loader => profile_loader
+        )
+        reverse_merge(profile_options)
+      end
+
+      def using_default_profile?
+        @profiles.empty? &&
+          profile_loader.lucid_yml_defined? &&
+          profile_loader.has_profile?(@default_profile)
+      end
+
+      def profile_loader
+        @profile_loader ||= Profile.new
+      end
+
+      def reverse_merge(other_options)
+        @options = other_options.options.merge(@options)
+        @options[:require] += other_options[:require]
+        @options[:excludes] += other_options[:excludes]
+        @options[:name_regexps] += other_options[:name_regexps]
+        @options[:tag_expressions] += other_options[:tag_expressions]
+        @options[:env_vars] = other_options[:env_vars].merge(@options[:env_vars])
+        if @options[:spec_source].empty?
+          @options[:spec_source] = other_options[:spec_source]
+        else
+          @overridden_paths += (other_options[:spec_source] - @options[:spec_source])
+        end
+        @options[:source] &= other_options[:source]
+        @options[:matchers] &= other_options[:matchers]
+        @options[:strict] |= other_options[:strict]
+        @options[:dry_run] |= other_options[:dry_run]
+
+        @profiles += other_options.profiles
+        @expanded_args += other_options.expanded_args
+
+        if @options[:formats].empty?
+          @options[:formats] = other_options[:formats]
+        else
+          @options[:formats] += other_options[:formats]
+          @options[:formats] = stdout_formats[0..0] + non_stdout_formats
+        end
+
+        self
+      end
+
+      def list_keywords_and_exit(lang)
+        require 'gherkin/i18n'
+        @out_stream.write(Gherkin::I18n.get(lang).keyword_table)
+        Kernel.exit(0)
+      end
+
+      def list_languages_and_exit
+        require 'gherkin/i18n'
+        @out_stream.write(Gherkin::I18n.language_table)
+        Kernel.exit(0)
+      end
+
+      def default_options
+        {
+          :strict       => false,
+          :require      => [],
+          :dry_run      => false,
+          :formats      => [],
+          :excludes     => [],
+          :tag_expressions  => [],
+          :name_regexps => [],
+          :env_vars     => {},
+          :diff_enabled => true,
+          :spec_type => "",
+          :library_path => ""
+        }
+      end
+    end
+
+  end
+end