lucid 0.0.4 → 0.0.5

data/lib/lucid/ast/tags.rb

@@ -0,0 +1,28 @@
+require 'gherkin/tag_expression'
+
+module Lucid
+  module AST
+    class Tags #:nodoc:
+      attr_reader :tags
+
+      def initialize(line, tags)
+        @line, @tags = line, tags
+      end
+
+      def accept(visitor)
+        return if Lucid.wants_to_quit
+        @tags.each do |tag|
+          visitor.visit_tag_name(tag.name)
+        end
+      end
+
+      def accept_hook?(hook)
+        Gherkin::TagExpression.new(hook.tag_expressions).evaluate(@tags)
+      end
+
+      def to_sexp
+        @tags.map{|tag| [:tag, tag.name]}
+      end
+    end
+  end
+end

data/lib/lucid/ast/tdl_walker.rb

@@ -0,0 +1,195 @@
+module Lucid
+  module AST
+    class TDLWalker
+      attr_accessor :configuration #:nodoc:
+      attr_reader   :runtime #:nodoc:
+
+      def initialize(runtime, listeners = [], configuration = Lucid::Configuration.default)
+        @runtime, @listeners, @configuration = runtime, listeners, configuration
+      end
+
+      def execute(scenario, skip_hooks)
+        runtime.with_hooks(scenario, skip_hooks) do
+          scenario.skip_invoke! if scenario.failed?
+          visit_steps(scenario.steps)
+        end
+      end
+
+      # The ability to visit specs is the first step in turning a spec into
+      # what is traditionally called a feature. The spec file and the feature
+      # are initially the same concept. When the spec is visited, the high
+      # level construct (feature, ability) is determined.
+      # @see Lucid::Runtime.run
+      def visit_features(features)
+        broadcast(features) do
+          features.accept(self)
+        end
+      end
+
+      def visit_feature(feature)
+        broadcast(feature) do
+          feature.accept(self)
+        end
+      end
+
+      def visit_comment(comment)
+        broadcast(comment) do
+          comment.accept(self)
+        end
+      end
+
+      def visit_comment_line(comment_line)
+        broadcast(comment_line)
+      end
+
+      def visit_tags(tags)
+        broadcast(tags) do
+          tags.accept(self)
+        end
+      end
+
+      def visit_tag_name(tag_name)
+        broadcast(tag_name)
+      end
+
+      def visit_feature_name(keyword, name)
+        broadcast(keyword, name)
+      end
+
+      # +feature_element+ is either Scenario or ScenarioOutline
+      def visit_feature_element(feature_element)
+        broadcast(feature_element) do
+          feature_element.accept(self)
+        end
+      end
+
+      def visit_background(background)
+        broadcast(background) do
+          background.accept(self)
+        end
+      end
+
+      def visit_background_name(keyword, name, file_colon_line, source_indent)
+        broadcast(keyword, name, file_colon_line, source_indent)
+      end
+
+      def visit_examples_array(examples_array)
+        broadcast(examples_array) do
+          examples_array.accept(self)
+        end
+      end
+
+      def visit_examples(examples)
+        broadcast(examples) do
+          examples.accept(self)
+        end
+      end
+
+      def visit_examples_name(keyword, name)
+        broadcast(keyword, name)
+      end
+
+      def visit_outline_table(outline_table)
+        broadcast(outline_table) do
+          outline_table.accept(self)
+        end
+      end
+
+      def visit_scenario_name(keyword, name, file_colon_line, source_indent)
+        broadcast(keyword, name, file_colon_line, source_indent)
+      end
+
+      def visit_steps(steps)
+        broadcast(steps) do
+          steps.accept(self)
+        end
+      end
+
+      def visit_step(step)
+        broadcast(step) do
+          step.accept(self)
+        end
+      end
+
+      def visit_step_result(keyword, step_match, multiline_arg, status, exception, source_indent, background, file_colon_line)
+        broadcast(keyword, step_match, multiline_arg, status, exception, source_indent, background, file_colon_line) do
+          visit_step_name(keyword, step_match, status, source_indent, background, file_colon_line)
+          visit_multiline_arg(multiline_arg) if multiline_arg
+          visit_exception(exception, status) if exception
+        end
+      end
+
+      def visit_step_name(keyword, step_match, status, source_indent, background, file_colon_line) #:nodoc:
+        broadcast(keyword, step_match, status, source_indent, background, file_colon_line)
+      end
+
+      def visit_multiline_arg(multiline_arg) #:nodoc:
+        broadcast(multiline_arg) do
+          multiline_arg.accept(self)
+        end
+      end
+
+      def visit_exception(exception, status) #:nodoc:
+        broadcast(exception, status)
+      end
+
+      def visit_doc_string(string)
+        broadcast(string)
+      end
+
+      def visit_table_row(table_row)
+        broadcast(table_row) do
+          table_row.accept(self)
+        end
+      end
+
+      def visit_table_cell(table_cell)
+        broadcast(table_cell) do
+          table_cell.accept(self)
+        end
+      end
+
+      def visit_table_cell_value(value, status)
+        broadcast(value, status)
+      end
+
+      # Print +messages+. This method can be called from within StepDefinitions.
+      def puts(*messages)
+        broadcast(*messages)
+      end
+
+      # Embed +file+ of +mime_type+ in the formatter. This method can be called from within StepDefinitions.
+      # For most formatters this is a no-op.
+      def embed(file, mime_type, label)
+        broadcast(file, mime_type, label)
+      end
+
+      private
+
+      def broadcast(*args, &block)
+        message = extract_method_name_from(caller)
+        message.gsub!('visit_', '')
+        if block_given?
+          send_to_all("before_#{message}", *args)
+          yield if block_given?
+          send_to_all("after_#{message}", *args)
+        else
+          send_to_all(message, *args)
+        end
+        self
+      end
+
+      def send_to_all(message, *args)
+        @listeners.each do |listener|
+          if listener.respond_to?(message)
+            listener.__send__(message, *args)
+          end
+        end
+      end
+      def extract_method_name_from(call_stack)
+        call_stack[0].match(/in `(.*)'/).captures[0]
+      end
+
+    end
+  end
+end

data/lib/lucid/cli/app.rb

@@ -0,0 +1,78 @@
+require 'gherkin'
+require 'optparse'
+require 'lucid'
+require 'logger'
+require 'lucid/parser'
+require 'lucid/spec_file'
+require 'lucid/cli/configuration'
+
+module Lucid
+  module CLI
+    class App
+      def initialize(args, stdin=STDIN, out=STDOUT, err=STDERR, kernel=Kernel)
+        raise "args can't be nil" unless args
+        raise "out can't be nil" unless out
+        raise "err can't be nil" unless err
+        raise "kernel can't be nil" unless kernel
+        @args   = args
+        @out    = out
+        @err    = err
+        @kernel = kernel
+        @configuration = nil
+      end
+
+      def start(existing_runtime = nil)
+        trap_interrupt
+
+        runtime = if existing_runtime
+          existing_runtime.configure(configuration)
+          existing_runtime
+        else
+          Runtime.new(configuration)
+        end
+
+        log.debug("Runtime: #{runtime.inspect}")
+
+        runtime.run
+        runtime.write_stepdefs_json
+        failure = runtime.results.failure? || Lucid.wants_to_quit
+        @kernel.exit(failure ? 1 : 0)
+      rescue ProfilesNotDefinedError, YmlLoadError, ProfileNotFound => e
+        @err.puts(e.message)
+      rescue SystemExit => e
+        @kernel.exit(e.status)
+      rescue Errno::EACCES, Errno::ENOENT => e
+        @err.puts("#{e.message} (#{e.class})")
+        @kernel.exit(1)
+      rescue Exception => e
+        @err.puts("#{e.message} (#{e.class})")
+        @err.puts(e.backtrace.join("\n"))
+        @kernel.exit(1)
+      end
+
+      def configuration
+        return @configuration if @configuration
+
+        @configuration = Configuration.new(@out, @err)
+        @configuration.parse(@args)
+        Lucid.logger = @configuration.log
+        log.debug("Configuration: #{@configuration.inspect}")
+        @configuration
+      end
+
+      private
+
+      def log
+        Lucid.logger
+      end
+
+      def trap_interrupt
+        trap('INT') do
+          exit!(1) if Lucid.wants_to_quit
+          Lucid.wants_to_quit = true
+          STDERR.puts "\nExiting. Interrupt again to exit immediately."
+        end
+      end
+    end
+  end
+end

data/lib/lucid/cli/configuration.rb

@@ -0,0 +1,261 @@
+require 'lucid/cli/options'
+require 'lucid/factory'
+require 'gherkin/tag_expression'
+
+module Lucid
+  module CLI
+    class YmlLoadError < StandardError; end
+    class ProfilesNotDefinedError < YmlLoadError; end
+    class ProfileNotFound < StandardError; end
+
+    class Configuration
+      include ObjectFactory
+
+      attr_reader :out_stream
+
+      def initialize(out_stream = STDOUT, err_stream = STDERR)
+        @out_stream   = out_stream
+        @err_stream = err_stream
+        @options = Options.new(@out_stream, @err_stream, :default_profile => 'default')
+      end
+
+      def parse(args)
+        @args = args
+        @options.parse(args)
+        log.debug("Options: #{@options.inspect}")
+
+        prepare_output_formatting
+        raise("You cannot use both --strict and --wip tags.") if strict? && wip?
+
+        @options[:tag_expression] = Gherkin::TagExpression.new(@options[:tag_expressions])
+
+        set_environment_variables
+      end
+
+      def verbose?
+        @options[:verbose]
+      end
+
+      def debug?
+        @options[:debug]
+      end
+
+      def strict?
+        @options[:strict]
+      end
+
+      def wip?
+        @options[:wip]
+      end
+
+      def guess?
+        @options[:guess]
+      end
+
+      def dry_run?
+        @options[:dry_run]
+      end
+
+      def expand?
+        @options[:expand]
+      end
+
+      def testdefs
+        @options[:testdefs]
+      end
+
+      def matcher_type
+        @options[:matcher_type] || :regexp
+      end
+
+      def establish_tdl_walker(runtime)
+        AST::TDLWalker.new(runtime, formatters(runtime), self)
+      end
+
+      def formatter_class(name)
+        if(lucid_format = Options::LUCID_FORMATS[name])
+          create_object_of(lucid_format[0])
+        else
+          create_object_of(name)
+        end
+      end
+
+      # The spec_repo is used to get all of the files that are in the
+      # "spec source" location. This location defaults to 'specs' but can
+      # be changed via a command line option. The spec repo will remove
+      # any directory names and, perhaps counter-intuitively, any spec
+      # files. The reason for this is that, by default, the "spec repo"
+      # contains everything that Lucid will need, whether that be
+      # test spec files or code files to support them.
+      def spec_repo
+        requires = @options[:require].empty? ? require_dirs : @options[:require]
+
+        files = requires.map do |path|
+          path = path.gsub(/\\/, '/')   # convert \ to /
+          path = path.gsub(/\/$/, '')   # removing trailing /
+          File.directory?(path) ? Dir["#{path}/**/*"] : path
+        end.flatten.uniq
+
+        extract_excluded_files(files)
+
+        files.reject! {|f| !File.file?(f)}
+        files.reject! {|f| File.extname(f) == ".#{spec_type}" }
+        files.reject! {|f| f =~ /^http/}
+        files.sort
+      end
+
+      # The definition context refers to any files that are found in the spec
+      # repository that are not spec files and that are not contained in the
+      # library path.
+      # @see Lucid::Runtime.load_execution_context
+      def definition_context
+        spec_repo.reject { |f| f=~ %r{/#{library_path}/} }
+      end
+
+      # The library context will store an array of all files that are found
+      # in the library_path. This path defaults to 'lucid' but can be changed
+      # via a command line option.
+      # @see Lucid::Runtime.load_execution_context
+      def library_context
+        library_files = spec_repo.select { |f| f =~ %r{/#{library_path}/} }
+        driver_file = library_files.select {|f| f =~ %r{/#{library_path}/driver\..*} }
+        non_driver_files = library_files - driver_file
+
+        @options[:dry_run] ? non_driver_files : driver_file + non_driver_files
+      end
+
+      # The spec files refer to any files found within the spec repository
+      # that match the specification file type. Note that this method is
+      # called from the specs action in a Runtime instance.
+      # @see Lucid::Runtime.specs
+      def spec_files
+        files = with_default_specs_path(spec_source).map do |path|
+          path = path.gsub(/\\/, '/')  # convert \ to /
+          path = path.chomp('/')       # removing trailing /
+          if File.directory?(path)
+            Dir["#{path}/**/*.#{spec_type}"].sort
+          elsif path[0..0] == '@' and # @listfile.txt
+              File.file?(path[1..-1]) # listfile.txt is a file
+            IO.read(path[1..-1]).split
+          else
+            path
+          end
+        end.flatten.uniq
+
+        log.info("Spec Files: #{files}")
+
+        extract_excluded_files(files)
+        files
+      end
+
+      # A call to spec_location will return the location of a spec repository.
+      def spec_location
+        dirs = spec_source.map { |f| File.directory?(f) ? f : File.dirname(f) }.uniq
+        dirs.delete('.') unless spec_source.include?('.')
+
+        with_default_specs_path(dirs)
+      end
+
+      # The "spec_type" refers to the file type (or extension) of spec files.
+      # This is how Lucid will recognize the files that should be treated as
+      # specs within a spec repository.
+      def spec_type
+        @options[:spec_type].empty? ? 'spec' : @options[:spec_type]
+      end
+
+      # The "library_path" refers to the location within the spec repository
+      # that holds the logic that supports the basic operations of the
+      # execution. This value will default to 'lucid' but the value of
+      # library_path can be changed via a command line option.
+      def library_path
+        @options[:library_path].empty? ? 'lucid' : @options[:library_path]
+      end
+
+      def log
+        logger = Logger.new(@out_stream)
+        logger.formatter = LogFormatter.new
+        logger.level = Logger::WARN
+        logger.level = Logger::INFO  if self.verbose?
+        logger.level = Logger::DEBUG if self.debug?
+        logger
+      end
+
+      def tag_expression
+        Gherkin::TagExpression.new(@options[:tag_expressions])
+      end
+
+      def filters
+        @options.filters
+      end
+
+      def formats
+        @options[:formats]
+      end
+
+      # The "spec_source" refers to the location of the spec repository. This
+      # value will default to 'specs' but the value of spec_source can be
+      # changed if a repository location is specified on the command line when
+      # calling Lucid.
+      def spec_source
+        @options[:spec_source]
+      end
+
+    private
+
+      def with_default_specs_path(paths)
+        return ['specs'] if paths.empty?
+        paths
+      end
+
+      def formatters(runtime)
+        # TODO: Remove the autoformat functionality; use the Gherkin CLI instead.
+        if @options[:autoformat]
+          require 'lucid/formatter/standard'
+          return [Formatter::Standard.new(runtime, nil, @options)]
+        end
+
+        @options[:formats].map do |format|
+          # The name will be a name, like 'standard'. The route will be the
+          # location where output is sent to, such as 'STDOUT'.
+          name = format[0]
+          route = format[1]
+          begin
+            formatter = formatter_class(name)
+            formatter.new(runtime, route, @options)
+          rescue Exception => e
+            e.message << "\nLucid is unable to create the formatter: #{name}"
+            raise e
+          end
+        end
+      end
+
+      def set_environment_variables
+        @options[:env_vars].each do |var, value|
+          ENV[var] = value
+        end
+      end
+
+      def prepare_output_formatting
+        @options[:formats] << ['standard', @out_stream] if @options[:formats].empty?
+        @options[:formats] = @options[:formats].sort_by{|f| f[1] == @out_stream ? -1 : 1}
+        @options[:formats].uniq!
+
+        streams = @options[:formats].map { |(_, stream)| stream }
+
+        if streams != streams.uniq
+          raise "All but one formatter must use --out, only one can print to each stream (or STDOUT)"
+        end
+      end
+
+      def extract_excluded_files(files)
+        files.reject! {|path| @options[:excludes].detect {|pattern| path =~ pattern } }
+      end
+
+      def require_dirs
+        spec_location + Dir['vendor/{gems,plugins}/*/lucid']
+      end
+
+    end
+
+  end
+end