mobiusloop 0.1.2

data/lib/cucumber/rb_support/rb_step_definition.rb

@@ -0,0 +1,131 @@
+require 'cucumber/step_match'
+require 'cucumber/step_argument'
+require 'cucumber/core_ext/string'
+
+module Cucumber
+  module RbSupport
+    # A Ruby Step Definition holds a Regexp and a Proc, and is created
+    # by calling <tt>Given</tt>, <tt>When</tt> or <tt>Then</tt>
+    # in the <tt>step_definitions</tt> ruby files. See also RbDsl.
+    #
+    # Example:
+    #
+    #   Given /I have (\d+) cucumbers in my belly/ do
+    #     # some code here
+    #   end
+    #
+    class RbStepDefinition
+
+      class MissingProc < StandardError
+        def message
+          "Step definitions must always have a proc or symbol"
+        end
+      end
+
+      class << self
+        def new(rb_language, pattern, proc_or_sym, options)
+          raise MissingProc if proc_or_sym.nil?
+          super rb_language, parse_pattern(pattern), create_proc(proc_or_sym, options)
+        end
+
+        private
+
+        def parse_pattern(pattern)
+          return pattern if pattern.is_a?(Regexp)
+          raise ArgumentError unless pattern.is_a?(String)
+          p = Regexp.escape(pattern)
+          p = p.gsub(/\\\$\w+/, '(.*)') # Replace $var with (.*)
+          Regexp.new("^#{p}$")
+        end
+
+        def create_proc(proc_or_sym, options)
+          return proc_or_sym if proc_or_sym.is_a?(Proc)
+          raise ArgumentError unless proc_or_sym.is_a?(Symbol)
+          message = proc_or_sym
+          target_proc = parse_target_proc_from(options)
+          patch_location_onto lambda { |*args|
+            target = instance_exec(&target_proc)
+            target.send(message, *args)
+          }
+        end
+
+        def patch_location_onto(block)
+          location = Core::Ast::Location.of_caller(5)
+          block.define_singleton_method(:source_location) { [location.file, location.line] }
+          block
+        end
+
+        def parse_target_proc_from(options)
+          return lambda { self } unless options.key?(:on)
+          target = options[:on]
+          case target
+          when Proc
+            target
+          when Symbol
+            lambda { self.send(target) }
+          else
+            lambda { raise ArgumentError, "Target must be a symbol or a proc" }
+          end
+        end
+      end
+
+      def initialize(rb_language, regexp, proc)
+        @rb_language, @regexp, @proc = rb_language, regexp, proc
+        @rb_language.available_step_definition(regexp_source, location)
+      end
+
+      def regexp_source
+        @regexp.inspect
+      end
+
+      def to_hash
+        flags = ''
+        flags += 'm' if (@regexp.options & Regexp::MULTILINE) != 0
+        flags += 'i' if (@regexp.options & Regexp::IGNORECASE) != 0
+        flags += 'x' if (@regexp.options & Regexp::EXTENDED) != 0
+        {'source' => @regexp.source, 'flags' => flags}
+      end
+
+      def ==(step_definition)
+        regexp_source == step_definition.regexp_source
+      end
+
+      def arguments_from(step_name)
+        args = StepArgument.arguments_from(@regexp, step_name)
+        @rb_language.invoked_step_definition(regexp_source, location) if args
+        args
+      end
+
+      def invoke(args)
+        begin
+          args = @rb_language.execute_transforms(args)
+          @rb_language.current_world.cucumber_instance_exec(true, regexp_source, *args, &@proc)
+        rescue Cucumber::ArityMismatchError => e
+          e.backtrace.unshift(self.backtrace_line)
+          raise e
+        end
+      end
+
+      def backtrace_line
+        "#{location.to_s}:in `#{regexp_source}'"
+      end
+
+      def file_colon_line
+        case @proc
+        when Proc
+          location.to_s
+        when Symbol
+          ":#{@proc}"
+        end
+      end
+
+      def location
+        @location ||= Cucumber::Core::Ast::Location.from_source_location(*@proc.source_location)
+      end
+
+      def file
+        @file ||= location.file
+      end
+    end
+  end
+end

data/lib/cucumber/rb_support/rb_transform.rb

@@ -0,0 +1,59 @@
+module Cucumber
+  module RbSupport
+    # A Ruby Transform holds a Regexp and a Proc, and is created
+    # by calling <tt>Transform in the <tt>support</tt> ruby files.
+    # See also RbDsl.
+    #
+    # Example:
+    #
+    #   Transform /^(\d+) cucumbers$/ do |cucumbers_string|
+    #     cucumbers_string.to_i
+    #   end
+    #
+    class RbTransform
+      class MissingProc < StandardError
+        def message
+          "Transforms must always have a proc with at least one argument"
+        end
+      end
+
+      def initialize(rb_language, pattern, proc)
+        raise MissingProc if proc.nil? || proc.arity < 1
+        @rb_language, @regexp, @proc = rb_language, Regexp.new(pattern), proc
+      end
+
+      def match(arg)
+        arg ? arg.match(@regexp) : nil
+      end
+
+      def invoke(arg)
+        if matched = match(arg)
+          args = matched.captures.empty? ? [arg] : matched.captures
+          @rb_language.current_world.cucumber_instance_exec(true, @regexp.inspect, *args, &@proc)
+        end
+      end
+
+      def to_s
+         convert_captures(strip_anchors(@regexp.source))
+      end
+
+    private
+      def convert_captures(regexp_source)
+        regexp_source
+          .gsub(/(\()(?!\?[<:=!])/,'(?:')
+          .gsub(/(\(\?<)(?![=!])/,'(?:<')
+      end
+
+      def strip_captures(regexp_source)
+        regexp_source.
+          gsub(/(\()/, '').
+          gsub(/(\))/, '')
+      end
+
+      def strip_anchors(regexp_source)
+        regexp_source.
+          gsub(/(^\^|\$$)/, '')
+      end
+    end
+  end
+end

data/lib/cucumber/rb_support/rb_world.rb

@@ -0,0 +1,149 @@
+require 'cucumber/gherkin/formatter/ansi_escapes'
+
+module Cucumber
+  module RbSupport
+    # Defines the basic DSL methods availlable in all Cucumber step definitions.
+    #
+    # You can, and probably should, extend this DSL with your own methods that
+    # make sense in your domain. For more on that, see {Cucumber::RbSupport::RbDsl#World}
+    module RbWorld
+
+      # @private
+      AnsiEscapes = Cucumber::Gherkin::Formatter::AnsiEscapes
+
+      # Call a Transform with a string from another Transform definition
+      def Transform(arg)
+        rb = @__cucumber_runtime.support_code.ruby
+        rb.execute_transforms([arg]).first
+      end
+
+      # @private
+      attr_writer :__cucumber_runtime, :__natural_language
+
+      # Run a single Gherkin step
+      # @example Call another step
+      #   step "I am logged in"
+      # @example Call a step with quotes in the name
+      #   step %{the user "Dave" is logged in}
+      # @example Passing a table
+      #   step "the following users exist:", table(%{
+      #     | name  | email           |
+      #     | Matt  | matt@matt.com   |
+      #     | Aslak | aslak@aslak.com |
+      #   })
+      # @example Passing a multiline string
+      #   step "the email should contain:", "Dear sir,\nYou've won a prize!\n"
+      # @param [String] name The name of the step
+      # @param [String,Cucumber::Ast::DocString,Cucumber::Ast::Table] multiline_argument
+      def step(name, raw_multiline_arg=nil)
+        location = Core::Ast::Location.of_caller
+        @__cucumber_runtime.invoke_dynamic_step(name, MultilineArgument.from(raw_multiline_arg, location))
+      end
+
+      # Run a snippet of Gherkin
+      # @example
+      #   steps %{
+      #     Given the user "Susan" exists
+      #     And I am logged in as "Susan"
+      #   }
+      # @param [String] steps_text The Gherkin snippet to run
+      def steps(steps_text)
+        location = Core::Ast::Location.of_caller
+        @__cucumber_runtime.invoke_dynamic_steps(steps_text, @__natural_language, location)
+      end
+
+      # Parse Gherkin into a {Cucumber::Ast::Table} object.
+      #
+      # Useful in conjunction with the #step method.
+      # @example Create a table
+      #   users = table(%{
+      #     | name  | email           |
+      #     | Matt  | matt@matt.com   |
+      #     | Aslak | aslak@aslak.com |
+      #   })
+      # @param [String] text_or_table The Gherkin string that represents the table
+      def table(text_or_table, file=nil, line_offset=0)
+        @__cucumber_runtime.table(text_or_table, file, line_offset)
+      end
+
+      # Create an {Cucumber::Ast::DocString} object
+      #
+      # Useful in conjunction with the #step method, when
+      # want to specify a content type.
+      # @example Create a multiline string
+      #   code = multiline_string(%{
+      #     puts "this is ruby code"
+      #   %}, 'ruby')
+      def doc_string(string_without_triple_quotes, content_type='', line_offset=0)
+        STDERR.puts AnsiEscapes.failed + "WARNING: #doc_string is deprecated. Just pass a regular String instead:" + caller[0] + AnsiEscapes.reset
+        # TODO: rename this method to multiline_string
+        @__cucumber_runtime.doc_string(string_without_triple_quotes, content_type, line_offset)
+      end
+
+      # @deprecated Use {#puts} instead.
+      def announce(*messages)
+        STDERR.puts AnsiEscapes.failed + "WARNING: #announce is deprecated. Use #puts instead:" + caller[0] + AnsiEscapes.reset
+        puts(*messages)
+      end
+
+      # Print a message to the output.
+      #
+      # @note Cucumber might surprise you with the behaviour of this method. Instead
+      #   of sending the output directly to STDOUT, Cucumber will intercept and cache
+      #   the message until the current step has finished, and then display it.
+      #
+      #   If you'd prefer to see the message immediately, call {Kernel.puts} instead.
+      def puts(*messages)
+        # Even though they won't be output until later, converting the messages to
+        # strings right away will protect them from modifications to their original
+        # objects in the mean time
+        messages.collect! { |message| "#{message}" }
+
+        @__cucumber_runtime.puts(*messages)
+      end
+
+      # Pause the tests and ask the operator for input
+      def ask(question, timeout_seconds=60)
+        @__cucumber_runtime.ask(question, timeout_seconds)
+      end
+
+      # Embed an image in the output
+      def embed(file, mime_type, label='Screenshot')
+        @__cucumber_runtime.embed(file, mime_type, label)
+      end
+
+      # Mark the matched step as pending.
+      def pending(message = "TODO")
+        if block_given?
+          begin
+            yield
+          rescue Exception
+            raise Pending, message
+          end
+          raise Pending, "Expected pending '#{message}' to fail. No Error was raised. No longer pending?"
+        else
+          raise Pending, message
+        end
+      end
+
+      # Skips this step and the remaining steps in the scenario
+      def skip_this_scenario(message = "Scenario skipped")
+        raise Core::Test::Result::Skipped, message
+      end
+
+      # Prints the list of modules that are included in the World
+      def inspect
+        modules = [self.class]
+        (class << self; self; end).instance_eval do
+          modules += included_modules
+        end
+        sprintf("#<%s:0x%x>", modules.join('+'), self.object_id)
+      end
+
+      # see {#inspect}
+      def to_s
+        inspect
+      end
+    end
+  end
+end

data/lib/cucumber/rb_support/snippet.rb

@@ -0,0 +1,170 @@
+module Cucumber
+  module RbSupport
+    module Snippet
+
+      ARGUMENT_PATTERNS = ['"([^"]*)"', '(\d+)']
+
+      class Generator
+        def self.register_on(configuration)
+          configuration.snippet_generators << new
+        end
+
+        def call(code_keyword, step_name, multiline_arg, snippet_type = :regexp)
+          snippet_class = typed_snippet_class(snippet_type)
+          snippet_class.new(code_keyword, step_name, multiline_arg).to_s
+        end
+
+        def typed_snippet_class(type)
+          SNIPPET_TYPES.fetch(type || :regexp)
+        end
+      end
+
+      class BaseSnippet
+
+        def initialize(code_keyword, pattern, multiline_argument)
+          @number_of_arguments = 0
+          @code_keyword = code_keyword
+          @pattern = replace_and_count_capturing_groups(pattern)
+          @multiline_argument = MultilineArgumentSnippet.new(multiline_argument)
+        end
+
+        def to_s
+          "#{step} #{do_block}"
+        end
+
+        def step
+          "#{code_keyword}#{typed_pattern}"
+        end
+
+        def self.cli_option_string(type)
+          "%-7s: %-28s e.g. %s" % [type, description, example]
+        end
+
+        private
+
+        attr_reader :code_keyword, :pattern, :multiline_argument, :number_of_arguments
+
+        def replace_and_count_capturing_groups(pattern)
+          modified_pattern = ::Regexp.escape(pattern).gsub('\ ', ' ').gsub('/', '\/')
+
+          ARGUMENT_PATTERNS.each do |argument_pattern|
+            modified_pattern.gsub!(::Regexp.new(argument_pattern), argument_pattern)
+            @number_of_arguments += modified_pattern.scan(argument_pattern).length
+          end
+
+          modified_pattern
+        end
+
+        def do_block
+          do_block = ""
+          do_block << "do#{arguments}\n"
+          multiline_argument.append_comment_to(do_block)
+          do_block << "  pending # Write code here that turns the phrase above into concrete actions\n"
+          do_block << "end"
+          do_block
+        end
+
+        def arguments
+          block_args = (0...number_of_arguments).map { |n| "arg#{n+1}" }
+          multiline_argument.append_block_argument_to(block_args)
+          block_args.empty? ? "" : " |#{block_args.join(", ")}|"
+        end
+
+        def self.example
+          new("Given", "missing step", MultilineArgument::None.new).step
+        end
+
+      end
+
+      class Regexp < BaseSnippet
+        def typed_pattern
+          "(/^#{pattern}$/)"
+        end
+
+        def self.description
+          "Snippets with parentheses"
+        end
+      end
+
+      class Classic < BaseSnippet
+        def typed_pattern
+          " /^#{pattern}$/"
+        end
+
+        def self.description
+          "Snippets without parentheses. Note that these cause a warning from modern versions of Ruby."
+        end
+      end
+
+      class Percent < BaseSnippet
+        def typed_pattern
+          " %r{^#{pattern}$}"
+        end
+
+        def self.description
+          "Snippets with percent regexp"
+        end
+      end
+
+      SNIPPET_TYPES = {
+        :regexp => Regexp,
+        :classic => Classic,
+        :percent => Percent
+      }
+
+      module MultilineArgumentSnippet
+
+        def self.new(multiline_argument)
+          builder = Builder.new
+          multiline_argument.describe_to(builder)
+          builder.result
+        end
+
+        class Builder
+          def doc_string(*args)
+            @result = DocString.new
+          end
+
+          def data_table(table, *args)
+            @result = DataTable.new(table)
+          end
+
+          def result
+            @result || None.new
+          end
+        end
+
+        class DocString
+          def append_block_argument_to(array)
+            array << 'string'
+          end
+
+          def append_comment_to(string)
+          end
+        end
+
+        class DataTable
+          def initialize(table)
+            @table = table
+          end
+
+          def append_block_argument_to(array)
+            array << 'table'
+          end
+
+          def append_comment_to(string)
+            string << "  # table is a #{Cucumber::MultilineArgument::DataTable.to_s}\n"
+          end
+        end
+
+        class None
+          def append_block_argument_to(array)
+          end
+
+          def append_comment_to(string)
+          end
+        end
+      end
+    end
+  end
+end