mobiusloop 0.1.2

data/lib/cucumber/runtime/before_hooks.rb

@@ -0,0 +1,27 @@
+require 'cucumber/hooks'
+
+module Cucumber
+  class Runtime
+    class BeforeHooks
+      def initialize(hooks, scenario)
+        @hooks = hooks
+        @scenario = scenario
+      end
+
+      def apply_to(test_case)
+        test_case.with_steps(
+          before_hooks(test_case.source) + test_case.test_steps
+        )
+      end
+
+      private
+
+      def before_hooks(source)
+        @hooks.map do |hook|
+          action_block = ->(result) { hook.invoke('Before', @scenario.with_result(result)) }
+          Hooks.before_hook(source, hook.location, &action_block)
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/runtime/for_programming_languages.rb

@@ -0,0 +1,66 @@
+require 'forwardable'
+require 'cucumber/core/ast/doc_string'
+require 'cucumber/core/ast/data_table'
+
+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
+
+      attr_reader :support_code
+
+      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_dynamic_steps,
+        :invoke_dynamic_step,
+        :load_programming_language
+
+      # Returns a Cucumber::MultilineArgument::DataTable 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=0)
+        if !file
+          location = Core::Ast::Location.of_caller
+        else
+          location = Core::Ast::Location.new(file, line)
+        end
+        MultilineArgument::DataTable.from(text_or_table, location)
+      end
+
+      # Returns a Cucumber::MultilineArgument::DocString for +body+.
+      #
+      def doc_string(body, content_type='', line_offset=0)
+        location = Core::Ast::Location.of_caller
+        MultilineArgument.doc_string(body, content_type, location)
+      end
+    end
+  end
+end

data/lib/cucumber/runtime/step_hooks.rb

@@ -0,0 +1,23 @@
+module Cucumber
+  class Runtime
+    class StepHooks
+      def initialize(hooks)
+        @hooks = hooks
+      end
+
+      def apply(test_steps)
+        test_steps.flat_map do |test_step|
+          [test_step] + after_step_hooks(test_step)
+        end
+      end
+
+      private
+      def after_step_hooks(test_step)
+        @hooks.map do |hook|
+          action = ->(*args) { hook.invoke('AfterStep', [args, test_step]) }
+          Hooks.after_step_hook(test_step.source, hook.location, &action)
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/runtime/support_code.rb

@@ -0,0 +1,151 @@
+require 'cucumber/constantize'
+require 'cucumber/runtime/for_programming_languages'
+require 'cucumber/runtime/step_hooks'
+require 'cucumber/runtime/before_hooks'
+require 'cucumber/runtime/after_hooks'
+require 'cucumber/events/step_match'
+require 'cucumber/gherkin/steps_parser'
+require 'cucumber/step_match_search'
+
+module Cucumber
+
+  class Runtime
+
+    class SupportCode
+
+      require 'forwardable'
+      class StepInvoker
+
+        def initialize(support_code)
+          @support_code = support_code
+        end
+
+        def steps(steps)
+          steps.each { |step| step(step) }
+        end
+
+        def step(step)
+          location = Core::Ast::Location.of_caller
+          @support_code.invoke_dynamic_step(step[:text], multiline_arg(step, location))
+        end
+
+        def multiline_arg(step, location)
+          if argument = step[:argument]
+            if argument[:type] == :DocString
+              MultilineArgument.doc_string(argument[:content], argument[:content_type], location)
+            else
+              MultilineArgument::DataTable.from(argument[:rows].map { |row| row[:cells].map { |cell| cell[:value] } })
+            end
+          else
+            MultilineArgument.from(nil)
+          end
+        end
+      end
+
+      include Constantize
+
+      attr_reader :ruby
+      def initialize(user_interface, configuration=Configuration.default)
+        @configuration = configuration
+        @runtime_facade = Runtime::ForProgrammingLanguages.new(self, user_interface)
+        @ruby = Cucumber::RbSupport::RbLanguage.new(@runtime_facade, @configuration)
+      end
+
+      def configure(new_configuration)
+        @configuration = Configuration.new(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_dynamic_steps(steps_text, i18n, location)
+        parser = Cucumber::Gherkin::StepsParser.new(StepInvoker.new(self), i18n.iso_code)
+        parser.parse(steps_text)
+      end
+
+      # @api private
+      # This allows users to attempt to find, match and execute steps
+      # from code as the features are running, as opposed to regular
+      # steps which are compiled into test steps before execution.
+      #
+      # These are commonly called nested steps.
+      def invoke_dynamic_step(step_name, multiline_argument, location=nil)
+        matches = step_matches(step_name)
+        raise UndefinedDynamicStep, step_name if matches.empty?
+        matches.first.invoke(multiline_argument)
+      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}/**/*.rb"] }.flatten
+        load_files! files
+      end
+
+      def unmatched_step_definitions
+        @ruby.unmatched_step_definitions
+      end
+
+      def fire_hook(name, *args)
+        @ruby.send(name, *args)
+      end
+
+      def step_definitions
+        @ruby.step_definitions
+      end
+
+      def find_after_step_hooks(test_case)
+        scenario = RunningTestCase.new(test_case)
+        hooks = @ruby.hooks_for(:after_step, scenario)
+        StepHooks.new hooks
+      end
+
+      def apply_before_hooks(test_case)
+        scenario = RunningTestCase.new(test_case)
+        hooks = @ruby.hooks_for(:before, scenario)
+        BeforeHooks.new(hooks, scenario).apply_to(test_case)
+      end
+
+      def apply_after_hooks(test_case)
+        scenario = RunningTestCase.new(test_case)
+        hooks = @ruby.hooks_for(:after, scenario)
+        AfterHooks.new(hooks, scenario).apply_to(test_case)
+      end
+
+      def find_around_hooks(test_case)
+        scenario = RunningTestCase.new(test_case)
+
+        @ruby.hooks_for(:around, scenario).map do |hook|
+          Hooks.around_hook(test_case.source) do |run_scenario|
+            hook.invoke('Around', scenario, &run_scenario)
+          end
+        end
+      end
+
+      private
+
+      def step_matches(step_name)
+        StepMatchSearch.new(@ruby.method(:step_matches), @configuration).call(step_name)
+      end
+
+      def load_file(file)
+        log.debug("  * #{file}\n")
+        @ruby.load_code_file(file)
+      end
+
+      def log
+        Cucumber.logger
+      end
+
+    end
+  end
+end

data/lib/cucumber/runtime/user_interface.rb

@@ -0,0 +1,85 @@
+require 'timeout'
+
+module Cucumber
+  class Runtime
+
+    module UserInterface
+      attr_writer :visitor
+
+      def visitor=(visitor)
+        @visitor = visitor
+      end
+
+      # 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
+          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

data/lib/cucumber/step_argument.rb

@@ -0,0 +1,25 @@
+module Cucumber
+  # Defines the location and value of a captured argument from the step
+  # text
+  class StepArgument
+    def self.arguments_from(regexp, step_name)
+      match = regexp.match(step_name)
+      if match
+        n = 0
+        match.captures.map do |val|
+          n += 1
+          offset = match.offset(n)[0]
+          new(offset, val)
+        end
+      else
+        nil
+      end
+    end
+
+    attr_reader :offset, :val
+
+    def initialize(offset, val)
+      @offset, @val = offset, val
+    end
+  end
+end

data/lib/cucumber/step_definition_light.rb

@@ -0,0 +1,20 @@
+module Cucumber
+  # Only used for keeping track of available and invoked step definitions
+  # in a way that also works for other programming languages (i.e. cuke4duke)
+  # Used for reporting purposes only (usage formatter).
+  class StepDefinitionLight
+    attr_reader :regexp_source, :location
+
+    def initialize(regexp_source, location)
+      @regexp_source, @location = regexp_source, location
+    end
+
+    def eql?(o)
+      regexp_source == o.regexp_source && location == o.location
+    end
+
+    def hash
+      regexp_source.hash + 31*location.to_s.hash
+    end
+  end
+end

data/lib/cucumber/step_definitions.rb

@@ -0,0 +1,13 @@
+module Cucumber
+  class StepDefinitions
+    def initialize(configuration = Configuration.default)
+      configuration = Configuration.new(configuration)
+      @support_code = Runtime::SupportCode.new(nil, configuration)
+      @support_code.load_files_from_paths(configuration.autoload_code_paths)
+    end
+
+    def to_json
+      @support_code.step_definitions.map{|stepdef| stepdef.to_hash}.to_json
+    end
+  end
+end

data/lib/cucumber/step_match.rb

@@ -0,0 +1,141 @@
+require 'cucumber/multiline_argument'
+
+module Cucumber
+
+  # Represents the match found between a Test Step and its activation
+  class StepMatch #:nodoc:
+    attr_reader :step_definition, :step_arguments
+
+    def initialize(step_definition, step_name, step_arguments)
+      raise "step_arguments can't be nil (but it can be an empty array)" if step_arguments.nil?
+      @step_definition, @name_to_match, @step_arguments = step_definition, step_name, step_arguments
+    end
+
+    def args
+      @step_arguments.map{|g| g.val }
+    end
+
+    def activate(test_step)
+      test_step.with_action(@step_definition.location) do
+        invoke(MultilineArgument.from_core(test_step.source.last.multiline_arg))
+      end
+    end
+
+    def invoke(multiline_arg)
+      all_args = deep_clone_args
+      multiline_arg.append_to(all_args)
+      @step_definition.invoke(all_args)
+    end
+
+    # Formats the matched arguments of the associated Step. This method
+    # is usually called from visitors, which render output.
+    #
+    # The +format+ can either be a String or a Proc.
+    #
+    # If it is a String it should be a format string according to
+    # <tt>Kernel#sprinf</tt>, for example:
+    #
+    #   '<span class="param">%s</span></tt>'
+    #
+    # If it is a Proc, it should take one argument and return the formatted
+    # argument, for example:
+    #
+    #   lambda { |param| "[#{param}]" }
+    #
+    def format_args(format = lambda{|a| a}, &proc)
+      replace_arguments(@name_to_match, @step_arguments, format, &proc)
+    end
+
+    def location
+      @step_definition.location
+    end
+
+    def file_colon_line
+      location.to_s
+    end
+
+    def backtrace_line
+      "#{file_colon_line}:in `#{@step_definition.regexp_source}'"
+    end
+
+    def text_length
+      @step_definition.regexp_source.unpack('U*').length
+    end
+
+    def replace_arguments(string, step_arguments, format, &proc)
+      s = string.dup
+      offset = past_offset = 0
+      step_arguments.each do |step_argument|
+        next if step_argument.offset.nil? || step_argument.offset < past_offset
+
+        replacement = if block_given?
+          proc.call(step_argument.val)
+        elsif Proc === format
+          format.call(step_argument.val)
+        else
+          format % step_argument.val
+        end
+
+        s[step_argument.offset + offset, step_argument.val.length] = replacement
+        offset += replacement.unpack('U*').length - step_argument.val.unpack('U*').length
+        past_offset = step_argument.offset + step_argument.val.length
+      end
+      s
+    end
+
+    def inspect #:nodoc:
+      "#<#{self.class}: #{location}>"
+    end
+
+    private
+    def deep_clone_args
+      Marshal.load( Marshal.dump( args ) )
+    end
+  end
+
+  class SkippingStepMatch
+    def activate(test_step)
+      return test_step.with_action { raise Core::Test::Result::Skipped.new }
+    end
+  end
+
+  class NoStepMatch #:nodoc:
+    attr_reader :step_definition, :name
+
+    def initialize(step, name)
+      @step = step
+      @name = name
+    end
+
+    def format_args(*args)
+      @name
+    end
+
+    def location
+      raise "No location for #{@step}" unless @step.location
+      @step.location
+    end
+
+    def file_colon_line
+      raise "No file:line for #{@step}" unless @step.file_colon_line
+      @step.file_colon_line
+    end
+
+    def backtrace_line
+      @step.backtrace_line
+    end
+
+    def text_length
+      @step.text_length
+    end
+
+    def step_arguments
+      []
+    end
+
+    def activate(test_step)
+      # noop
+      return test_step
+    end
+  end
+end