casecumber 1.0.2.1

data/lib/cucumber/runtime/features_loader.rb

@@ -0,0 +1,62 @@
+require 'cucumber/errors'
+
+module Cucumber
+  class Runtime
+    
+    class FeaturesLoader
+      include Formatter::Duration
+
+      def initialize(feature_files, filters, tag_expression)
+        @feature_files, @filters, @tag_expression = feature_files, filters, tag_expression
+      end
+      
+      def features
+        load unless @features
+        @features
+      end
+      
+    private
+    
+      def load
+        features = Ast::Features.new
+
+        tag_counts = {}
+        start = Time.new
+        log.debug("Features:\n")
+        @feature_files.each do |f|
+          feature_file = FeatureFile.new(f)
+          feature = feature_file.parse(@filters, tag_counts)
+          if feature
+            features.add_feature(feature)
+            log.debug("  * #{f}\n")
+          end
+        end
+        duration = Time.now - start
+        log.debug("Parsing feature files took #{format_duration(duration)}\n\n")
+
+        check_tag_limits(tag_counts)
+
+        @features = features
+      end
+
+      def check_tag_limits(tag_counts)
+        error_messages = []
+        @tag_expression.limits.each do |tag_name, tag_limit|
+          tag_locations = (tag_counts[tag_name] || [])
+          tag_count = tag_locations.length
+          if tag_count > tag_limit
+            error = "#{tag_name} occurred #{tag_count} times, but the limit was set to #{tag_limit}\n  " +
+              tag_locations.join("\n  ")
+            error_messages << error
+          end
+        end
+        raise TagExcess.new(error_messages) if error_messages.any?
+      end
+      
+      def log
+        Cucumber.logger
+      end
+    end
+
+  end
+end

data/lib/cucumber/runtime/for_programming_languages.rb

@@ -0,0 +1,67 @@
+require 'forwardable'
+
+module Cucumber
+  class Runtime
+    # This is what a programming language will consider to be a runtime.
+    # 
+    # It's a thin class that directs the handul of methods needed by the
+    # programming languages to the right place.
+    class ForProgrammingLanguages
+      extend Forwardable
+    
+      def initialize(support_code, user_interface)
+        @support_code, @user_interface = support_code, user_interface
+      end
+
+      def_delegators :@user_interface,
+        :embed,
+        :ask,
+        :puts,
+        :features_paths,
+        :step_match
+    
+      def_delegators :@support_code,
+        :invoke_steps,
+        :invoke,
+        :load_programming_language
+    
+      # Returns a Cucumber::Ast::Table for +text_or_table+, which can either
+      # be a String:
+      #
+      #   table(%{
+      #     | account | description | amount |
+      #     | INT-100 | Taxi        | 114    |
+      #     | CUC-101 | Peeler      | 22     |
+      #   })
+      #
+      # or a 2D Array:
+      #
+      #   table([
+      #     %w{ account description amount },
+      #     %w{ INT-100 Taxi        114    },
+      #     %w{ CUC-101 Peeler      22     }
+      #   ])
+      #
+      def table(text_or_table, file=nil, line_offset=0)
+        if Array === text_or_table
+          Ast::Table.new(text_or_table)
+        else
+          Ast::Table.parse(text_or_table, file, line_offset)
+        end
+      end
+
+      # Returns a regular String for +string_with_triple_quotes+. Example:
+      #
+      #   """
+      #    hello
+      #   world
+      #   """
+      #
+      # Is retured as: " hello\nworld"
+      #
+      def doc_string(string_with_triple_quotes, file=nil, line_offset=0)
+        Ast::DocString.parse(string_with_triple_quotes)
+      end
+    end
+  end
+end

data/lib/cucumber/runtime/results.rb

@@ -0,0 +1,64 @@
+module Cucumber
+  class Runtime
+    
+    class Results
+      def initialize(configuration)
+        @configuration = configuration
+
+        # Optimization - quicker lookup.
+        @inserted_steps = {}
+        @inserted_scenarios = {}
+      end
+
+      def configure(new_configuration)
+        @configuration = Configuration.parse(new_configuration)
+      end
+
+      def step_visited(step) #:nodoc:
+        step_id = step.object_id
+
+        unless @inserted_steps.has_key?(step_id)
+          @inserted_steps[step_id] = step
+          steps.push(step)
+        end
+      end
+      
+      def scenario_visited(scenario) #:nodoc:
+        scenario_id = scenario.object_id
+
+        unless @inserted_scenarios.has_key?(scenario_id)
+          @inserted_scenarios[scenario_id] = scenario
+          scenarios.push(scenario)
+        end
+      end
+      
+      def steps(status = nil) #:nodoc:
+        @steps ||= []
+        if(status)
+          @steps.select{|step| step.status == status}
+        else
+          @steps
+        end
+      end
+      
+      def scenarios(status = nil) #:nodoc:
+        @scenarios ||= []
+        if(status)
+          @scenarios.select{|scenario| scenario.status == status}
+        else
+          @scenarios
+        end
+      end
+      
+      def failure?
+        if @configuration.wip?
+          scenarios(:passed).any?
+        else
+          scenarios(:failed).any? ||
+          (@configuration.strict? && (steps(:undefined).any? || steps(:pending).any?))
+        end
+      end
+    end
+    
+  end
+end

data/lib/cucumber/runtime/support_code.rb

@@ -0,0 +1,203 @@
+require 'cucumber/constantize'
+require 'cucumber/runtime/for_programming_languages'
+
+module Cucumber
+  class Runtime
+    
+    class SupportCode
+      
+      require 'forwardable'
+      class StepInvoker
+        include Gherkin::Rubify
+
+        def initialize(support_code)
+          @support_code = support_code
+        end
+
+        def uri(uri)
+        end
+
+        def step(step)
+          cucumber_multiline_arg = case(rubify(step.multiline_arg))
+          when Gherkin::Formatter::Model::DocString
+            step.multiline_arg.value
+          when Array
+            Ast::Table.new(step.multiline_arg.map{|row| row.cells})
+          else
+            nil
+          end
+          @support_code.invoke(step.name, cucumber_multiline_arg) 
+        end
+
+        def eof
+        end
+      end
+    
+      include Constantize
+      
+      def initialize(user_interface, configuration={})
+        @configuration = Configuration.parse(configuration)
+        @runtime_facade = Runtime::ForProgrammingLanguages.new(self, user_interface)
+        @unsupported_programming_languages = []
+        @programming_languages = []
+        @language_map = {}
+      end
+      
+      def configure(new_configuration)
+        @configuration = Configuration.parse(new_configuration)
+      end
+    
+      # Invokes a series of steps +steps_text+. Example:
+      #
+      #   invoke(%Q{
+      #     Given I have 8 cukes in my belly
+      #     Then I should not be thirsty
+      #   })
+      def invoke_steps(steps_text, i18n, file_colon_line)
+        file, line = file_colon_line.split(':')
+        parser = Gherkin::Parser::Parser.new(StepInvoker.new(self), true, 'steps')
+        parser.parse(steps_text, file, line.to_i)
+      end
+      
+      # Loads and registers programming language implementation.
+      # Instances are cached, so calling with the same argument
+      # twice will return the same instance.
+      #
+      def load_programming_language(ext)
+        return @language_map[ext] if @language_map[ext]
+        programming_language_class = constantize("Cucumber::#{ext.capitalize}Support::#{ext.capitalize}Language")
+        programming_language = programming_language_class.new(@runtime_facade)
+        @programming_languages << programming_language
+        @language_map[ext] = programming_language
+        programming_language
+      end
+    
+      def load_files!(files)
+        log.debug("Code:\n")
+        files.each do |file|
+          load_file(file)
+        end
+        log.debug("\n")
+      end
+      
+      def load_files_from_paths(paths)
+        files = paths.map { |path| Dir["#{path}/**/*"] }.flatten
+        load_files! files
+      end
+    
+      def unmatched_step_definitions
+        @programming_languages.map do |programming_language| 
+          programming_language.unmatched_step_definitions
+        end.flatten
+      end
+
+      def snippet_text(step_keyword, step_name, multiline_arg_class) #:nodoc:
+        load_programming_language('rb') if unknown_programming_language?
+        @programming_languages.map do |programming_language|
+          programming_language.snippet_text(step_keyword, step_name, multiline_arg_class)
+        end.join("\n")
+      end
+    
+      def unknown_programming_language?
+        @programming_languages.empty?
+      end
+    
+      def fire_hook(name, *args)
+        @programming_languages.each do |programming_language|
+          programming_language.send(name, *args)
+        end
+      end
+    
+      def around(scenario, block)
+        @programming_languages.reverse.inject(block) do |blk, programming_language|
+          proc do
+            programming_language.around(scenario) do
+              blk.call(scenario)
+            end
+          end
+        end.call
+      end
+      
+      def step_definitions
+        @programming_languages.map do |programming_language|
+          programming_language.step_definitions
+        end.flatten
+      end
+    
+      def step_match(step_name, name_to_report=nil) #:nodoc:
+        matches = matches(step_name, name_to_report)
+        raise Undefined.new(step_name) if matches.empty?
+        matches = best_matches(step_name, matches) if matches.size > 1 && guess_step_matches?
+        raise Ambiguous.new(step_name, matches, guess_step_matches?) if matches.size > 1
+        matches[0]
+      end
+    
+      def invoke(step_name, multiline_argument=nil)
+        # It is very important to leave multiline_argument=nil as a vararg. Cuke4Duke needs it that way. 
+        begin
+          step_match(step_name).invoke(multiline_argument)
+        rescue Exception => e
+          e.nested! if Undefined === e
+          raise e
+        end
+      end
+
+    private
+  
+      def guess_step_matches?
+        @configuration.guess?
+      end
+    
+      def matches(step_name, name_to_report)
+        @programming_languages.map do |programming_language| 
+          programming_language.step_matches(step_name, name_to_report).to_a
+        end.flatten
+      end
+
+      def best_matches(step_name, step_matches) #:nodoc:
+        no_groups      = step_matches.select {|step_match| step_match.args.length == 0}
+        max_arg_length = step_matches.map {|step_match| step_match.args.length }.max
+        top_groups     = step_matches.select {|step_match| step_match.args.length == max_arg_length }
+
+        if no_groups.any?
+          longest_regexp_length = no_groups.map {|step_match| step_match.text_length }.max
+          no_groups.select {|step_match| step_match.text_length == longest_regexp_length }
+        elsif top_groups.any?
+          shortest_capture_length = top_groups.map {|step_match| step_match.args.inject(0) {|sum, c| sum + c.to_s.length } }.min
+          top_groups.select {|step_match| step_match.args.inject(0) {|sum, c| sum + c.to_s.length } == shortest_capture_length }
+        else
+          top_groups
+        end
+      end
+    
+      def load_file(file)
+        if programming_language = programming_language_for(file)
+          log.debug("  * #{file}\n")
+          programming_language.load_code_file(file)
+        else
+          log.debug("  * #{file} [NOT SUPPORTED]\n")
+        end
+      end
+    
+      def log
+        Cucumber.logger
+      end
+    
+      def programming_language_for(step_def_file)
+        if ext = File.extname(step_def_file)[1..-1]
+          return nil if @unsupported_programming_languages.index(ext)
+          begin
+            load_programming_language(ext)
+          rescue LoadError => e
+            log.debug("Failed to load '#{ext}' programming language for file #{step_def_file}: #{e.message}\n")
+            @unsupported_programming_languages << ext
+            nil
+          end
+        else
+          nil
+        end
+      end
+    
+    end
+  end
+end

data/lib/cucumber/runtime/user_interface.rb

@@ -0,0 +1,81 @@
+require 'timeout'
+
+module Cucumber
+  class Runtime
+
+    module UserInterface
+      attr_writer :visitor
+
+      # Output +messages+ alongside the formatted output.
+      # This is an alternative to using Kernel#puts - it will display
+      # nicer, and in all outputs (in case you use several formatters)
+      #
+      def puts(*messages)
+        @visitor.puts(*messages)
+      end
+
+      # Suspends execution and prompts +question+ to the console (STDOUT).
+      # An operator (manual tester) can then enter a line of text and hit
+      # <ENTER>. The entered text is returned, and both +question+ and
+      # the result is added to the output using #puts.
+      #
+      # If you want a beep to happen (to grab the manual tester's attention),
+      # just prepend ASCII character 7 to the question:
+      #
+      #   ask("#{7.chr}How many cukes are in the external system?")
+      #
+      # If that doesn't issue a beep, you can shell out to something else
+      # that makes a sound before invoking #ask.
+      #
+      def ask(question, timeout_seconds)
+        STDOUT.puts(question)
+        STDOUT.flush
+        puts(question)
+
+        if(Cucumber::JRUBY)
+          answer = jruby_gets(timeout_seconds)
+        else
+          answer = mri_gets(timeout_seconds)
+        end
+
+        if(answer)
+          puts(answer)
+          answer
+        else
+          raise("Waited for input for #{timeout_seconds} seconds, then timed out.")
+        end
+      end
+
+      # Embed +src+ of MIME type +mime_type+ into the output. The +src+ argument may
+      # be a path to a file, or if it's an image it may also be a Base64 encoded image. 
+      # The embedded data may or may not be ignored, depending on what kind of formatter(s) are active.
+      #
+      def embed(src, mime_type, label)
+        @visitor.embed(src, mime_type, label)
+      end
+
+    private
+    
+      def mri_gets(timeout_seconds)
+        begin
+          Timeout.timeout(timeout_seconds) do
+            STDIN.gets
+          end
+        rescue Timeout::Error => e
+          nil
+        end
+      end
+
+      def jruby_gets(timeout_seconds)
+        answer = nil
+        t = java.lang.Thread.new do
+          answer = STDIN.gets
+        end
+        t.start
+        t.join(timeout_seconds * 1000)
+        answer
+      end
+    end
+    
+  end
+end