lucid 0.3.3 → 0.4.0

data/lib/lucid/ast/table.rb

@@ -451,7 +451,7 @@ module Lucid
         Lucid::Term::ANSIColor.coloring = options[:color]
         formatter = Formatter::Standard.new(nil, io, options)
         formatter.instance_variable_set('@indent', options[:indent])
-        TDLWalker.new(nil, [formatter]).visit_multiline_arg(self)
+        Walker.new(nil, [formatter]).visit_multiline_arg(self)
 
         Lucid::Term::ANSIColor.coloring = c
         io.rewind

data/lib/lucid/ast/{tdl_walker.rb → walker.rb}

@@ -1,21 +1,20 @@
 module Lucid
   module AST
-    class TDLWalker
-      attr_accessor :configuration #:nodoc:
-      attr_reader   :runtime #:nodoc:
+    class Walker
+      attr_accessor :context
+      attr_reader   :runtime
 
-      def initialize(runtime, listeners = [], configuration = Lucid::Configuration.default)
-        @runtime, @listeners, @configuration = runtime, listeners, configuration
+      def initialize(runtime, listeners = [], context = Lucid::Context.default)
+        @runtime, @listeners, @context = runtime, listeners, context
       end
 
       # This is being used to forward on messages from the AST to
-      # the formatters. This is being done in lieu of the explicit
-      # forwarding that was previously done.
+      # the formatters.
       def method_missing(message, *args, &block)
-        broadcast_message(message, *args, &block)
+        send_message(message, *args, &block)
       end
 
-      def visit_multiline_arg(multiline_arg) #:nodoc:
+      def visit_multiline_arg(multiline_arg)
         broadcast(multiline_arg) do
           multiline_arg.accept(self)
         end
@@ -25,32 +24,32 @@ module Lucid
 
       def broadcast(*args, &block)
         message = extract_method_name_from(caller[0])
-        broadcast_message message, *args, &block
+        send_message message, *args, &block
         self
       end
 
-      def broadcast_message(message, *args, &block)
+      def send_message(message, *args, &block)
         return self if Lucid.wants_to_quit
         message = message.to_s.gsub('visit_', '')
         if block_given?
-          send_to_all("before_#{message}", *args)
+          send_to_listeners("before_#{message}", *args)
           yield if block_given?
-          send_to_all("after_#{message}", *args)
+          send_to_listeners("after_#{message}", *args)
         else
-          send_to_all(message, *args)
+          send_to_listeners(message, *args)
         end
         self
       end
 
-      def send_to_all(message, *args)
+      def send_to_listeners(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]
         match = call_stack.match(/in `(.*)'/)
         match.captures[0]
       end

data/lib/lucid/cli/app.rb

@@ -3,7 +3,7 @@ require 'optparse'
 require 'lucid'
 require 'logger'
 require 'lucid/spec_file'
-require 'lucid/cli/configuration'
+require 'lucid/cli/context'
 
 module Lucid
   module CLI
@@ -11,7 +11,7 @@ module Lucid
       def self.start(args)
         new(args).start!
       end
-      
+
       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
@@ -21,24 +21,25 @@ module Lucid
         @out    = out
         @err    = err
         @kernel = kernel
-        @configuration = nil
+        @context = nil
       end
-      
-      def start!(existing_runtime = nil)
+
+      def start!(existing_context = nil)
         trap_interrupt
 
-        runtime = if existing_runtime
-          existing_runtime.configure(configuration)
-          existing_runtime
+        context_loader = if existing_context
+          existing_context.configure(load_context)
+          existing_context
         else
-          Runtime.new(configuration)
+          ContextLoader.new(load_context)
         end
 
-        log.debug("Runtime: #{runtime.inspect}")
+        log.debug('Context Loader')
+        log.debug(context_loader)
 
-        runtime.run
-        runtime.write_testdefs_json
-        failure = runtime.results.failure? || Lucid.wants_to_quit
+        context_loader.execute
+        context_loader.write_testdefs_json
+        failure = context_loader.results.failure? || Lucid.wants_to_quit
         @kernel.exit(failure ? 1 : 0)
       rescue ProfilesNotDefinedError, YmlLoadError, ProfileNotFound => e
         @err.puts(e.message)
@@ -53,14 +54,15 @@ module Lucid
         @kernel.exit(1)
       end
 
-      def configuration
-        return @configuration if @configuration
+      def load_context
+        return @context if @context
 
-        @configuration = Configuration.new(@out, @err)
-        @configuration.parse(@args)
-        Lucid.logger = @configuration.log
-        log.debug("Configuration: #{@configuration.inspect}")
-        @configuration
+        @context = Context.new(@out, @err)
+        @context.parse_options(@args)
+        Lucid.logger = @context.log
+        log.debug('Context:')
+        log.debug(@context)
+        @context
       end
 
       private
@@ -73,7 +75,7 @@ module Lucid
         trap('INT') do
           exit!(1) if Lucid.wants_to_quit
           Lucid.wants_to_quit = true
-          STDERR.puts "\nExiting. Interrupt again to exit immediately."
+          STDERR.puts "\nExiting Lucid execution.\nInterrupt again to exit immediately."
         end
       end
     end

data/lib/lucid/cli/{configuration.rb → context.rb}

@@ -8,23 +8,24 @@ module Lucid
     class ProfilesNotDefinedError < YmlLoadError; end
     class ProfileNotFound < StandardError; end
 
-    class Configuration
+    class Context
       include Factory
 
       attr_reader :out_stream
 
       def initialize(out_stream = STDOUT, err_stream = STDERR)
-        @out_stream   = out_stream
+        @out_stream = out_stream
         @err_stream = err_stream
         @options = Options.new(@out_stream, @err_stream, :default_profile => 'default')
       end
 
-      def parse(args)
+      def parse_options(args)
         @args = args
         @options.parse(args)
-        log.debug("Options: #{@options.inspect}")
+        log.debug('Options:')
+        log.debug(@options)
 
-        prepare_output_formatting
+        set_formatter
         raise('You cannot use both --strict and --wip tags.') if strict? && wip?
 
         @options[:tag_expression] = Gherkin::TagExpression.new(@options[:tag_expressions])
@@ -68,24 +69,26 @@ module Lucid
         @options[:matcher_type] || :regexp
       end
 
-      def establish_tdl_walker(runtime)
-        AST::TDLWalker.new(runtime, formatters(runtime), self)
+      # @see Lucid::ContextLoader.execute
+      def establish_ast_walker(runtime)
+        Lucid::AST::Walker.new(runtime, formatters(runtime), self)
       end
 
-      def formatter_class(name)
-        if(lucid_format = Options::LUCID_FORMATS[name])
+      def formatter_instance(name)
+        if lucid_format = Options::LUCID_FORMATS[name]
           create_object_of(lucid_format[0])
         else
           create_object_of(name)
         end
       end
 
+      # @return [Array] list of non-spec, executable files from all required locations
       def spec_requires
         requires = @options[:require].empty? ? require_dirs : @options[:require]
 
         files = requires.map do |path|
-          path = path.gsub(/\\/, '/')   # convert \ to /
-          path = path.gsub(/\/$/, '')   # removing trailing /
+          path = path.gsub(/\\/, '/')
+          path = path.gsub(/\/$/, '')
           File.directory?(path) ? Dir["#{path}/**/*"] : path
         end.flatten.uniq
 
@@ -93,7 +96,7 @@ module Lucid
 
         files.reject! {|f| !File.file?(f)}
 
-        spec_types = spec_type.each do |type|
+        spec_type.each do |type|
           files.reject! {|f| File.extname(f) == ".#{type}" }
         end
 
@@ -102,28 +105,49 @@ module Lucid
         files.sort
       end
 
-      # @see Lucid::Runtime.load_execution_context
+      # Returns all definition files that exist in the default or provided
+      # execution path.
+      #
+      # @return [Array] executable files outside of the library path
+      # @see Lucid::ContextLoader.load_execution_context
       def definition_context
-        spec_requires.reject { |f| f=~ %r{#{library_path}} }
+        definition_files = spec_requires.reject { |f| f =~ %r{#{library_path}} }
+        log.info("Definition Files:\n#{definition_files}")
+
+        non_test_definitions = spec_requires.reject { |f| f =~ %r{#{steps_path}|#{library_path}} }
+        log.info("Non-Test Definition Files:\n#{non_test_definitions}")
+
+        @options[:dry_run] ? definition_files - non_test_definitions : definition_files
       end
 
-      # @see Lucid::Runtime.load_execution_context
+      # Returns all library files that exist in the default or provided
+      # library path. During a dry run, the driver file will not be
+      # returned as part of the executing context.
+      #
+      # @return [Array] valid executable files in the library path
+      # @see Lucid::ContextLoader.load_execution_context
       def library_context
         library_files = spec_requires.select { |f| f =~ %r{#{library_path}} }
-        driver = library_files.select {|f| f =~ %r{#{driver_file}} }
+        log.info("(Library Context) Library Files:\n#{library_files}")
 
-        log.info("Driver File Found: #{driver}")
+        driver = library_files.select {|f| f =~ %r{#{driver_file}} }
+        log.info("(Library Context) Driver File:\n#{driver}")
 
         non_driver_files = library_files - driver
+        log.info("(Library Context) Non-Driver Files:\n#{non_driver_files}")
 
         @options[:dry_run] ? non_driver_files : driver + non_driver_files
       end
 
-      # @see Lucid::Runtime.specs
-      def spec_files
+      # Returns all spec files that exist in the default or provided spec
+      # repository.
+      #
+      # @return [Array] spec files from the repo
+      # @see Lucid::RepoRunner.load_spec_context
+      def spec_context
         files = specs_path(spec_source).map do |path|
-          path = path.gsub(/\\/, '/')  # convert \ to /
-          path = path.chomp('/')       # removing trailing /
+          path = path.gsub(/\\/, '/')
+          path = path.chomp('/')
 
           files_to_sort = []
 
@@ -134,7 +158,7 @@ module Lucid
 
             files_to_sort
           elsif path[0..0] == '@' and # @listfile.txt
-              File.file?(path[1..-1]) # listfile.txt is a file
+            File.file?(path[1..-1]) # listfile.txt is a file
             IO.read(path[1..-1]).split
           else
             path
@@ -154,16 +178,23 @@ module Lucid
       end
 
       def spec_type
-        @options[:spec_type]
-
+        @options[:spec_types]
       end
 
       def library_path
-        @options[:library_path].empty? ? 'common' : @options[:library_path]
+        @options[:library_path]
       end
 
       def driver_file
-        @options[:driver_file].empty? ? 'driver' : @options[:driver_file]
+        @options[:driver_file]
+      end
+
+      def steps_path
+        @options[:steps_path]
+      end
+
+      def definitions_path
+        @options[:definitions_path]
       end
 
       def log
@@ -191,7 +222,7 @@ module Lucid
         @options[:spec_source]
       end
 
-    private
+      private
 
       def specs_path(paths)
         return ['specs'] if paths.empty?
@@ -200,16 +231,13 @@ module Lucid
 
       def formatters(runtime)
         @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
+            formatter = formatter_instance(format[0])
+            formatter.new(runtime, format[1], @options)
+          rescue LoadError
+            message = "\nLucid is unable to create the formatter: #{format[0]}"
+            log.error(message)
+            Kernel.exit(1)
           end
         end
       end
@@ -220,7 +248,7 @@ module Lucid
         end
       end
 
-      def prepare_output_formatting
+      def set_formatter
         @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!
@@ -237,7 +265,7 @@ module Lucid
       end
 
       def require_dirs
-        spec_location + Dir["#{library_path}", 'pages', 'steps']
+        spec_location + Dir["#{library_path}", "#{definitions_path}", "#{steps_path}"]
       end
 
     end

data/lib/lucid/cli/options.rb

@@ -1,3 +1,4 @@
+require 'English'
 require 'lucid/cli/profile'
 require 'lucid/formatter/ansicolor'
 require 'lucid/interface_rb/rb_language'
@@ -83,7 +84,9 @@ module Lucid
         @args.extend(::OptionParser::Arguable)
 
         @args.options do |opts|
-          opts.banner = ['Lucid: Test Description Language Execution Engine',
+          opts.banner = ['Lucid Framework',
+                         'Test Description Language Specification and Execution Engine',
+                         '',
                          'Usage: lucid [options] [ [FILE|DIR|URL][:LINE[:LINE]*] ]+', '', ''
           ].join("\n")
 
@@ -91,9 +94,16 @@ module Lucid
             @options[:library_path] = path
           end
 
+          opts.on('--definition-path PATH', 'Location of spec project definition files.') do |path|
+            @options[:definitions_path] = path
+          end
+
+          opts.on('--steps-path PATH', 'Location of spec project test step files.') do |path|
+            @options[:steps_path] = path
+          end
+
           opts.on('--spec-type TYPE', 'The file type (extension) for Lucid specifications.') do |type|
-            #@options[:spec_type] = type
-            @options[:spec_type] << type
+            @options[:spec_types] << type
           end
 
           opts.on('--driver-file FILE', 'The file for Lucid to connect to an execution library.') do |file|
@@ -103,19 +113,17 @@ module Lucid
           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.',
-                  'Assuming a default specs repo configuration, files under',
-                  "directories named \"common\\support\" will always be loaded",
-                  'before any others.',
-                  'This option can be specified multiple times.') do |v|
-            @options[:require] << v
-            if(Lucid::JRUBY && File.directory?(v))
+                  'Require resources (paths or individual files) prior to executing',
+                  'the test specs. If no require options are passed, then Lucid will',
+                  'use its default path and file settings via automatic loading. If',
+                  'require options are passed, however, then automatic loading will',
+                  'be disabled, which means loading any resources must be done via',
+                  'explicit uses of this option. The require option can be specified',
+                  'multiple times.') do |resource|
+            @options[:require] << resource
+            if(Lucid::JRUBY && File.directory?(resource))
               require 'java'
-              $CLASSPATH << v
+              $CLASSPATH << resource
             end
           end
 
@@ -143,8 +151,9 @@ module Lucid
 
           opts.separator ''
 
-          opts.on('-d', '--dry-run', 'Invokes formatters without executing the steps.',
-                  'This also omits the loading of your common/support/driver.rb file if it exists.') do
+          opts.on('-d', '--dry-run', 'Performs spec parsing without test execution.',
+                  'Performing a dry run omits loading of the driver file as well as',
+                  'any page or activity definitions.') do
             @options[:dry_run] = true
           end
 
@@ -305,24 +314,13 @@ module Lucid
             Kernel.exit(0)
           end
         end
-        #end.parse!
 
         begin
           @args.parse!
         rescue OptionParser::InvalidOption
-          if $!.to_s =~ /invalid option\:\s+((?:-)?-\S+)/
-            puts "You specified an invalid option: #{$1}"
-            puts 'Please run lucid --help to see the list of available options.'
-          end
-
+          invalid_option($ERROR_INFO)
         rescue OptionParser::MissingArgument
-          if $!.to_s =~ /missing argument\:\s+((?:-)?-\S+)/
-            puts "You specified an valid option (#{$1}), but with an invalid argument."
-            puts 'Make sure you are providing the expected argument for the option.'
-            puts 'Run lucid --help to see the list of available options.'
-          end
-
-          Kernel.exit(1)
+          missing_argument($ERROR_INFO)
         end
 
         if @quiet
@@ -335,9 +333,12 @@ module Lucid
 
         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
+        # The next statement is critical because it takes whatever is left
+        # from the command line when all the valid options are parsed. This
+        # would have to be the spec repository. The empty check is because
+        # even if no args are passed, an empty array will be passed to the
+        # spec_repos key, which overwrites the default option.
+        @options[:spec_source] = @args.dup #unless args.empty?
 
         establish_profile
 
@@ -348,17 +349,33 @@ module Lucid
         @profiles - [@default_profile]
       end
 
-      # @see Lucid::CLI::Configuration.filters
+      # @see Lucid::CLI::Context.filters
       def filters
         @options.values_at(:name_regexps, :tag_expressions).select{|v| !v.empty?}.first || []
       end
 
-    protected
+      protected
 
       attr_reader :options, :profiles, :expanded_args
       protected :options, :profiles, :expanded_args
 
-    private
+      private
+
+      def invalid_option(error)
+        if error.to_s =~ /invalid option:\s+((?:-)?-\S+)/
+          puts "You specified an #{$MATCH}\n\n"
+          puts 'Run lucid --help to see the list of available options.'
+        end
+        Kernel.exit(1)
+      end
+
+      def missing_argument(error)
+        if error.to_s =~ /(?:missing argument:\s+)((?:-)?-\S+)/
+          puts "Valid option with #{$MATCH}\n\n"
+          puts 'Run lucid --help to see the list of available options.'
+        end
+        Kernel.exit(1)
+      end
 
       def non_stdout_formats
         @options[:formats].select {|format, output| output != @out_stream }
@@ -435,7 +452,7 @@ module Lucid
         @options[:dry_run] |= other_options[:dry_run]
 
         @options[:library_path] += other_options[:library_path]
-        @options[:spec_type] += other_options[:spec_type]
+        @options[:spec_types] += other_options[:spec_types]
         @options[:driver_file] += other_options[:driver_file]
 
         @profiles += other_options.profiles
@@ -474,9 +491,11 @@ module Lucid
           :name_regexps     => [],
           :env_vars         => {},
           :diff_enabled     => true,
-          :spec_type        => %w(feature spec story),
-          :library_path     => '',
-          :driver_file      => ''
+          :spec_types       => %w(feature spec story),
+          :library_path     => 'common',
+          :definitions_path => 'pages',
+          :steps_path       => 'steps',
+          :driver_file      => 'driver'
         }
       end
     end