lucid 0.0.6 → 0.0.7

data/lib/lucid/ast/step_result.rb

@@ -0,0 +1,34 @@
+module Lucid
+  module AST
+    class StepResult
+      attr_reader :keyword, :step_match, :exception, :status, :background
+      attr_reader :step_multiline_class, :file_colon_line
+
+      def initialize(keyword, step_match, multiline_arg, status, exception, source_indent, background, file_colon_line)
+        @keyword, @step_match, @multiline_arg, @status, @exception, @source_indent, @background, @file_colon_line = keyword, step_match, multiline_arg, status, exception, source_indent, background, file_colon_line
+      end
+
+      def accept(visitor)
+        visitor.visit_step_name(@keyword, @step_match, @status, @source_indent, @background, @file_colon_line)
+        visitor.visit_multiline_arg(@multiline_arg) if @multiline_arg
+        visitor.visit_exception(@exception, @status) if @exception
+      end
+
+      def args
+        [@keyword, @step_match, @multiline_arg, @status, @exception, @source_indent, @background, @file_colon_line]
+      end
+
+      def step_name
+        @step_match.name
+      end
+
+      def step_definition
+        @step_match.step_definition
+      end
+
+      def step_arguments
+        @step_match.step_arguments
+      end
+    end
+  end
+end

data/lib/lucid/ast/table.rb

@@ -179,7 +179,7 @@ module Lucid
       def accept(visitor) #:nodoc:
         return if Lucid.wants_to_quit
         cells_rows.each do |row|
-          visitor.visit_table_row(row)
+          row.accept(visitor)
         end
         nil
       end
@@ -631,8 +631,10 @@ module Lucid
 
         def accept(visitor)
           return if Lucid.wants_to_quit
-          each do |cell|
-            visitor.visit_table_cell(cell)
+          visitor.visit_table_row(self) do
+            each do |cell|
+              cell.accept(visitor)
+            end
           end
           nil
         end
@@ -687,7 +689,10 @@ module Lucid
 
         def accept(visitor)
           return if Lucid.wants_to_quit
-          visitor.visit_table_cell_value(value, status)
+
+          visitor.visit_table_cell(self) do
+            visitor.visit_table_cell_value(value, status)
+          end
         end
 
         def inspect!

data/lib/lucid/ast/tags.rb

@@ -11,8 +11,10 @@ module Lucid
 
       def accept(visitor)
         return if Lucid.wants_to_quit
-        @tags.each do |tag|
-          visitor.visit_tag_name(tag.name)
+        visitor.visit_tags(self) do
+          @tags.each do |tag|
+            visitor.visit_tag_name(tag.name)
+          end
         end
       end
 

data/lib/lucid/ast/tdl_walker.rb

@@ -11,7 +11,7 @@ module Lucid
       def execute(scenario, skip_hooks)
         runtime.with_hooks(scenario, skip_hooks) do
           scenario.skip_invoke! if scenario.failed?
-          visit_steps(scenario.steps)
+          scenario.steps.accept(self)
         end
       end
 
@@ -20,108 +20,100 @@ module Lucid
       # 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_features(features, &block)
+      #  broadcast(features, &block)
+      #end
 
-      def visit_feature(feature)
-        broadcast(feature) do
-          feature.accept(self)
-        end
-      end
+      #def visit_feature(feature, &block)
+      #  broadcast(feature, &block)
+      #end
 
-      def visit_comment(comment)
-        broadcast(comment) do
-          comment.accept(self)
-        end
-      end
+      #def visit_comment(comment, &block)
+      #  broadcast(comment, &block)
+      #end
 
-      def visit_comment_line(comment_line)
-        broadcast(comment_line)
-      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_tags(tags, &block)
+      #  broadcast(tags, &block)
+      #end
 
-      def visit_tag_name(tag_name)
-        broadcast(tag_name)
-      end
+      #def visit_tag_name(tag_name)
+      #  broadcast(tag_name)
+      #end
 
-      def visit_feature_name(keyword, name)
-        broadcast(keyword, 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
+      # Note that a feature_element refers to either a Scenario or
+      # a ScenarioOutline.
+      #def visit_feature_element(feature_element, &block)
+      #  broadcast(feature_element, &block)
+      #end
 
-      def visit_background(background)
-        broadcast(background) do
-          background.accept(self)
-        end
-      end
+      #def visit_background(background, &block)
+      #  broadcast(background, &block)
+      #end
 
-      def visit_background_name(keyword, name, file_colon_line, source_indent)
-        broadcast(keyword, name, file_colon_line, source_indent)
-      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_array(examples_array, &block)
+      #  broadcast(examples_array, &block)
+      #end
 
-      def visit_examples(examples)
-        broadcast(examples) do
-          examples.accept(self)
-        end
-      end
+      #def visit_examples(examples, &block)
+      #  broadcast(examples, &block)
+      #end
 
-      def visit_examples_name(keyword, name)
-        broadcast(keyword, name)
-      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_outline_table(outline_table, &block)
+      #  broadcast(outline_table, &block)
+      #end
 
-      def visit_scenario_name(keyword, name, file_colon_line, source_indent)
-        broadcast(keyword, name, file_colon_line, source_indent)
-      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_steps(steps, &block)
+      #  broadcast(steps, &block)
+      #end
 
-      def visit_step(step)
-        broadcast(step) do
-          step.accept(self)
-        end
+      #def visit_step(step, &block)
+      #  broadcast(step, &block)
+      #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.
+      def method_missing(message, *args, &block)
+        broadcast_message(message, *args, &block)
       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
+      #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_result(step_result)
+        broadcast(step_result) do
+          step_result.accept(self)
         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_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
@@ -129,29 +121,25 @@ module Lucid
         end
       end
 
-      def visit_exception(exception, status) #:nodoc:
-        broadcast(exception, status)
-      end
+      #def visit_exception(exception, status) #:nodoc:
+      #  broadcast(exception, status)
+      #end
 
-      def visit_doc_string(string)
-        broadcast(string)
-      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_row(table_row, &block)
+      #  broadcast(table_row, &block)
+      #end
 
-      def visit_table_cell(table_cell)
-        broadcast(table_cell) do
-          table_cell.accept(self)
-        end
-      end
+      #def visit_table_cell(table_cell, &block)
+      #  broadcast(table_cell, &block)
+      #end
 
-      def visit_table_cell_value(value, status)
-        broadcast(value, status)
-      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)
@@ -167,8 +155,13 @@ module Lucid
       private
 
       def broadcast(*args, &block)
-        message = extract_method_name_from(caller)
-        message.gsub!('visit_', '')
+        message = extract_method_name_from(caller[0])
+        broadcast_message message, *args, &block
+        self
+      end
+
+      def broadcast_message(message, *args, &block)
+        message = message.to_s.gsub('visit_', '')
         if block_given?
           send_to_all("before_#{message}", *args)
           yield if block_given?
@@ -187,7 +180,9 @@ module Lucid
         end
       end
       def extract_method_name_from(call_stack)
-        call_stack[0].match(/in `(.*)'/).captures[0]
+        #call_stack[0].match(/in `(.*)'/).captures[0]
+        match = call_stack.match(/in `(.*)'/)
+        match.captures[0]
       end
 
     end

data/lib/lucid/cli/app.rb

@@ -34,7 +34,7 @@ module Lucid
         log.debug("Runtime: #{runtime.inspect}")
 
         runtime.run
-        runtime.write_stepdefs_json
+        runtime.write_testdefs_json
         failure = runtime.results.failure? || Lucid.wants_to_quit
         @kernel.exit(failure ? 1 : 0)
       rescue ProfilesNotDefinedError, YmlLoadError, ProfileNotFound => e

data/lib/lucid/cli/configuration.rb

@@ -80,14 +80,7 @@ module Lucid
         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
+      def spec_requires
         requires = @options[:require].empty? ? require_dirs : @options[:require]
 
         files = requires.map do |path|
@@ -101,35 +94,30 @@ module Lucid
         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}/} }
+        spec_requires.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
+        library_files = spec_requires.select { |f| f =~ %r{#{library_path}} }
+        driver = library_files.select {|f| f =~ %r{#{driver_file}} }
+
+        log.info("Driver File Found: #{driver}")
+
+        non_driver_files = library_files - driver
 
-        @options[:dry_run] ? non_driver_files : driver_file + non_driver_files
+        @options[:dry_run] ? non_driver_files : driver + 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|
+        files = specs_path(spec_source).map do |path|
           path = path.gsub(/\\/, '/')  # convert \ to /
           path = path.chomp('/')       # removing trailing /
           if File.directory?(path)
@@ -142,33 +130,27 @@ module Lucid
           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)
+        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]
+        @options[:library_path].empty? ? 'common' : @options[:library_path]
+      end
+
+      def driver_file
+        @options[:driver_file].empty? ? 'driver' : @options[:driver_file]
       end
 
       def log
@@ -192,17 +174,13 @@ module Lucid
         @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)
+      def specs_path(paths)
         return ['specs'] if paths.empty?
         paths
       end
@@ -252,7 +230,7 @@ module Lucid
       end
 
       def require_dirs
-        spec_location + Dir['vendor/{gems,plugins}/*/lucid']
+        spec_location + Dir["#{library_path}", 'pages', 'steps']
       end
 
     end