lucid 0.3.3 → 0.4.0

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

@@ -1,6 +1,5 @@
 module Lucid
-  # The base class for configuring settings for a Lucid run.
-  class Configuration
+  class Context
     def self.default
       new
     end
@@ -46,7 +45,7 @@ module Lucid
 
     def default_options
       {
-        :autoload_code_paths => ['common', 'steps', 'pages']
+        :autoload_code_paths => %w(common steps pages)
       }
     end
   end

data/lib/lucid/{runtime.rb → context_loader.rb}

@@ -2,59 +2,56 @@ require 'fileutils'
 require 'multi_json'
 require 'gherkin/rubify'
 require 'gherkin/i18n'
-require 'lucid/configuration'
+require 'lucid/context'
 require 'lucid/load_path'
-require 'lucid/interface_methods'
+require 'lucid/interface'
 require 'lucid/formatter/duration'
-require 'lucid/runtime/interface_io'
-require 'lucid/runtime/specs_loader'
-require 'lucid/runtime/results'
-require 'lucid/runtime/orchestrator'
+require 'lucid/interface_io'
+require 'lucid/spec_loader'
+require 'lucid/results'
+require 'lucid/orchestrator'
 
 module Lucid
-  class Runtime
+  class ContextLoader
     attr_reader :results, :orchestrator
 
     include Formatter::Duration
-    include Runtime::InterfaceIO
-
-    def initialize(configuration = Configuration.default)
-      if defined?(Test::Unit::Runner)
-        Test::Unit::Runner.module_eval("@@stop_auto_run = true")
-      end
+    include ContextLoader::InterfaceIO
 
+    def initialize(context = Context.default)
       @current_scenario = nil
-      @configuration = Configuration.parse(configuration)
-      @orchestrator = Orchestrator.new(self, @configuration)
-      @results = Results.new(@configuration)
+      @context = Context.parse(context)
+      @orchestrator = Orchestrator.new(self, @context)
+      @results = Results.new(@context)
     end
 
-    # Used to take an existing runtime and change its configuration.
-    def configure(new_configuration)
-      @configuration = Configuration.parse(new_configuration)
-      @orchestrator.configure(@configuration)
-      @results.configure(@configuration)
+    # Used to take an existing Lucid operation context and change the
+    # configuration of that context.
+    def configure(new_context)
+      @context = Context.parse(new_context)
+      @orchestrator.configure(@context)
+      @results.configure(@context)
     end
 
     def load_code_language(language)
       @orchestrator.load_code_language(language)
     end
 
-    def run
+    def execute
       load_execution_context
       fire_after_configuration_hook
 
-      tdl_walker = @configuration.establish_tdl_walker(self)
-      self.visitor = tdl_walker
+      ast_walker = @context.establish_ast_walker(self)
+      self.visitor = ast_walker
 
-      specs.accept(tdl_walker)
+      load_spec_context.accept(ast_walker)
     end
 
     def specs_paths
-      @configuration.spec_source
+      @context.spec_source
     end
 
-    def step_visited(step) #:nodoc:
+    def step_visited(step)
       @results.step_visited(step)
     end
 
@@ -66,7 +63,7 @@ module Lucid
       @results.steps(status)
     end
 
-    def step_match(step_name, name_to_report=nil) #:nodoc:
+    def step_match(step_name, name_to_report=nil)
       @orchestrator.step_match(step_name, name_to_report)
     end
 
@@ -74,7 +71,7 @@ module Lucid
       @orchestrator.unmatched_step_definitions
     end
 
-    def matcher_text(step_keyword, step_name, multiline_arg_class) #:nodoc:
+    def matcher_text(step_keyword, step_name, multiline_arg_class)
       @orchestrator.matcher_text(Gherkin::I18n.code_keyword_for(step_keyword), step_name, multiline_arg_class)
     end
 
@@ -86,7 +83,7 @@ module Lucid
       end
     end
 
-    def around(scenario, skip_hooks=false, &block) #:nodoc:
+    def around(scenario, skip_hooks=false, &block)
       if skip_hooks
         yield
         return
@@ -95,27 +92,27 @@ module Lucid
       @orchestrator.around(scenario, block)
     end
 
-    def before_and_after(scenario, skip_hooks=false) #:nodoc:
+    def before_and_after(scenario, skip_hooks=false)
       before(scenario) unless skip_hooks
       yield scenario
       after(scenario) unless skip_hooks
       @results.scenario_visited(scenario)
     end
 
-    def before(scenario) #:nodoc:
-      return if @configuration.dry_run? || @current_scenario
+    def before(scenario)
+      return if @context.dry_run? || @current_scenario
       @current_scenario = scenario
       @orchestrator.fire_hook(:before, scenario)
     end
 
-    def after(scenario) #:nodoc:
+    def after(scenario)
       @current_scenario = nil
-      return if @configuration.dry_run?
+      return if @context.dry_run?
       @orchestrator.fire_hook(:after, scenario)
     end
 
     def after_step #:nodoc:
-      return if @configuration.dry_run?
+      return if @context.dry_run?
       @orchestrator.fire_hook(:execute_after_step, @current_scenario)
     end
 
@@ -124,7 +121,7 @@ module Lucid
     end
 
     def write_testdefs_json
-      if(@configuration.testdefs)
+      if(@context.testdefs)
         stepdefs = []
         @orchestrator.step_definitions.sort{|a,b| a.to_hash['source'] <=> a.to_hash['source']}.each do |stepdef|
           stepdef_hash = stepdef.to_hash
@@ -151,24 +148,23 @@ module Lucid
           stepdef_hash['steps'] = steps.uniq.sort {|a,b| a['name'] <=> b['name']}
           stepdefs << stepdef_hash
         end
-        if !File.directory?(@configuration.testdefs)
-          FileUtils.mkdir_p(@configuration.testdefs)
+        if !File.directory?(@context.testdefs)
+          FileUtils.mkdir_p(@context.testdefs)
         end
-        File.open(File.join(@configuration.testdefs, 'testdefs.json'), 'w') do |io|
+        File.open(File.join(@context.testdefs, 'testdefs.json'), 'w') do |io|
           io.write(MultiJson.dump(stepdefs, :pretty => true))
         end
       end
     end
 
-    # Returns AST::DocString for +string_without_triple_quotes+.
-    def doc_string(string_without_triple_quotes, content_type='', line_offset=0)
-      AST::DocString.new(string_without_triple_quotes,content_type)
+    def doc_string(non_docstring, content_type='', line_offset=0)
+      Lucid::AST::DocString.new(non_docstring, content_type)
     end
 
-  private
+    private
 
-    def fire_after_configuration_hook #:nodoc
-      @orchestrator.fire_hook(:after_configuration, @configuration)
+    def fire_after_configuration_hook
+      @orchestrator.fire_hook(:after_configuration, @context)
     end
 
     # The specs is used to begin loading the executable specs. This is as
@@ -176,22 +172,23 @@ module Lucid
     # already handled. A SpecsLoader instance is created and this is what
     # makes sure that a spec file can be turned into a code construct
     # (a SpecFile instance) which in turn can be broken down into an AST.
-    def specs
-      @loader ||= Runtime::SpecsLoader.new(
-        @configuration.spec_files,
-        @configuration.filters,
-        @configuration.tag_expression)
-      @loader.specs
-    end
-
-    # Loading the execution context means getting all of the loadable files
-    # in the spec repository. Loadable files means any code language type
-    # files. These files are sent to an orchestrator instance that will be
-    # responsible for loading them. The loading of these files provides the
-    # execution context for Lucid as it runs executable specs.
+    #
+    # @return [Object] Instance of Lucid::AST::Spec
+    def load_spec_context
+      @loader ||= Lucid::ContextLoader::SpecLoader.new(
+        @context.spec_context,
+        @context.filters,
+        @context.tag_expression)
+      @loader.load_specs
+    end
+
+    # Determines what files should be included as part of the execution
+    # context for Lucid as it runs executable specs. The "library" refers
+    # to code that will be common to all specs while "definition" refers
+    # to page/activity definitions as well as test definitions, which are
+    # usually referred to as steps.
     def load_execution_context
-      files = @configuration.library_context + @configuration.definition_context
-      log.info("Runtime Load Execution Context: #{files}")
+      files = @context.library_context + @context.definition_context
       @orchestrator.load_files(files)
     end
 

data/lib/lucid/{runtime/facade.rb → facade.rb}

@@ -1,7 +1,7 @@
 require 'forwardable'
 
 module Lucid
-  class Runtime
+  class ContextLoader
     # This is what a programming language will consider to be a runtime.
     #
     # It's a thin class that directs the specific methods needed by the
@@ -43,15 +43,14 @@ module Lucid
       #
       def table(text_or_table, file=nil, line_offset=0)
         if Array === text_or_table
-          AST::Table.new(text_or_table)
+          Lucid::AST::Table.new(text_or_table)
         else
-          AST::Table.parse(text_or_table, file, line_offset)
+          Lucid::AST::Table.parse(text_or_table, file, line_offset)
         end
       end
 
-      # Returns AST::DocString
-      def doc_string(string_without_triple_quotes, content_type='', line_offset=0)
-        AST::DocString.new(string_without_triple_quotes,content_type)
+      def doc_string(non_docstring, content_type='', line_offset=0)
+        Lucid::AST::DocString.new(non_docstring, content_type)
       end
     end
   end

data/lib/lucid/formatter/ansicolor.rb

@@ -1,17 +1,17 @@
 require 'lucid/platform'
-require 'lucid/term/ansicolor'
+require 'lucid/ansicolor'
 
 if Lucid::IRONRUBY
   begin
     require 'iron-term-ansicolor'
   rescue LoadError
-    STDERR.puts %{*** WARNING: You must "gem install iron-term-ansicolor" to get colored ouput in on IronRuby}
+    STDERR.puts %{*** WARNING: You must "gem install iron-term-ansicolor" to get colored ouput with IronRuby}
   end
 end
 
 if Lucid::WINDOWS_MRI
   unless ENV['ANSICON']
-    STDERR.puts %{*** WARNING: You must use ANSICON 1.31 or higher (https://github.com/adoxa/ansicon/) to get colored output on Windows}
+    STDERR.puts %{*** WARNING: You must use ANSICON (https://github.com/adoxa/ansicon/) to get colored output on Windows}
     Lucid::Term::ANSIColor.coloring = false
   end
 end
@@ -74,7 +74,8 @@ module Lucid
         'tag'       => 'cyan'
       })
 
-      if ENV['LUCID_COLORS'] # Example: export LUCID_COLORS="passed=red:failed=yellow"
+      # Example: export LUCID_COLORS="passed=red:failed=yellow"
+      if ENV['LUCID_COLORS']
         ENV['LUCID_COLORS'].split(':').each do |pair|
           a = pair.split('=')
           ALIASES[a[0]] = a[1]
@@ -126,7 +127,7 @@ module Lucid
           if e.class.name == 'TermInfo::TermInfoError'
             STDERR.puts '*** WARNING ***'
             STDERR.puts "You have the genki-ruby-terminfo gem installed, but you haven't set your TERM variable."
-            STDERR.puts 'Try setting it to TERM=xterm-256color to get grey color in output.'
+            STDERR.puts 'Try setting it to TERM=xterm-256color to get color in output.'
             STDERR.puts "\n"
             alias grey white
           else
@@ -135,8 +136,8 @@ module Lucid
         end
       end
 
-      def self.define_real_grey #:nodoc:
-        def grey(string) #:nodoc:
+      def self.define_real_grey
+        def grey(string)
           if ::Lucid::Term::ANSIColor.coloring?
             "\e[90m#{string}\e[0m"
           else
@@ -147,20 +148,20 @@ module Lucid
 
       define_grey
 
-      def cukes(n)
+      def lucid(n)
         ('(::) ' * n).strip
       end
 
-      def green_cukes(n)
-        blink(green(cukes(n)))
+      def green_lucid(n)
+        blink(green(lucid(n)))
       end
 
-      def red_cukes(n)
-        blink(red(cukes(n)))
+      def red_lucid(n)
+        blink(red(lucid(n)))
       end
 
-      def yellow_cukes(n)
-        blink(yellow(cukes(n)))
+      def yellow_lucid(n)
+        blink(yellow(lucid(n)))
       end
     end
   end

data/lib/lucid/formatter/debug.rb

@@ -1,5 +1,5 @@
 require 'lucid/formatter/progress'
-require 'lucid/step_definition_light'
+require 'lucid/step_definition_usage'
 
 module Lucid
   module Formatter

data/lib/lucid/formatter/usage.rb

@@ -1,12 +1,12 @@
 require 'lucid/formatter/progress'
-require 'lucid/step_definition_light'
+require 'lucid/step_definition_usage'
 
 module Lucid
   module Formatter
     class Usage < Progress
       include Console
 
-      class StepDefKey < StepDefinitionLight
+      class StepDefKey < StepDefinitionUsage
         attr_accessor :mean_duration, :status
       end
 

data/lib/lucid/interface.rb

@@ -1,8 +1,129 @@
+require 'lucid/step_match'
+require 'lucid/step_definition_usage'
+
 module Lucid
   # This module defines the API for programming language support in Lucid.
   # While Lucid itself is written in Ruby, any programming language can
   # be supported by implementing this API. Each language implementation
   # must manage its own events and must execute them at appropriate times.
   module Interface
+    module InterfaceMethods
+      def around(scenario)
+        execute_around(scenario) do
+          yield
+        end
+      end
+
+      def before(scenario)
+        begin_scenario(scenario)
+        execute_before(scenario)
+      end
+
+      def after(scenario)
+        execute_after(scenario)
+        end_scenario
+      end
+
+      def after_configuration(configuration)
+        hooks[:after_configuration].each do |hook|
+          hook.invoke('AfterConfiguration', configuration)
+        end
+      end
+
+      def execute_after_step(scenario)
+        hooks_for(:after_step, scenario).each do |hook|
+          invoke(hook, 'AfterStep', scenario, false)
+        end
+      end
+
+      def execute_transforms(args)
+        args.map do |arg|
+          matching_transform = transforms.detect {|transform| transform.match(arg) }
+          matching_transform ? matching_transform.invoke(arg) : arg
+        end
+      end
+
+      def add_hook(phase, hook)
+        hooks[phase.to_sym] << hook
+        hook
+      end
+
+      def clear_hooks
+        @hooks = nil
+      end
+
+      def add_transform(transform)
+        transforms.unshift transform
+        transform
+      end
+
+      def hooks_for(phase, scenario) #:nodoc:
+        hooks[phase.to_sym].select{|hook| scenario.accept_hook?(hook)}
+      end
+
+      def unmatched_step_definitions
+        available_step_definition_hash.keys - invoked_step_definition_hash.keys
+      end
+
+      def available_step_definition(regexp_source, file_colon_line)
+        available_step_definition_hash[StepDefinitionUsage.new(regexp_source, file_colon_line)] = nil
+      end
+
+      def invoked_step_definition(regexp_source, file_colon_line)
+        invoked_step_definition_hash[StepDefinitionUsage.new(regexp_source, file_colon_line)] = nil
+      end
+
+      private
+
+      def available_step_definition_hash
+        @available_step_definition_hash ||= {}
+      end
+
+      def invoked_step_definition_hash
+        @invoked_step_definition_hash ||= {}
+      end
+
+      def hooks
+        @hooks ||= Hash.new{|h,k| h[k] = []}
+      end
+
+      def transforms
+        @transforms ||= []
+      end
+
+      def execute_around(scenario, &block)
+        hooks_for(:around, scenario).reverse.inject(block) do |blk, hook|
+          proc do
+            invoke(hook, 'Around', scenario, true) do
+              blk.call(scenario)
+            end
+          end
+        end.call
+      end
+
+      def execute_before(scenario)
+        hooks_for(:before, scenario).each do |hook|
+          invoke(hook, 'Before', scenario, true)
+        end
+      end
+
+      def execute_after(scenario)
+        hooks_for(:after, scenario).reverse_each do |hook|
+          invoke(hook, 'After', scenario, true)
+        end
+      end
+
+      def invoke(hook, location, scenario, exception_fails_scenario, &block)
+        begin
+          hook.invoke(location, scenario, &block)
+        rescue Exception => exception
+          if exception_fails_scenario
+            scenario.fail!(exception)
+          else
+            raise
+          end
+        end
+      end
+    end
   end
 end