cucumber 3.0.0.pre.1 → 3.0.0.pre.2

data/lib/cucumber/runtime/after_hooks.rb

@@ -19,7 +19,7 @@ module Cucumber
         @hooks.map do |hook|
           action = ->(result) { hook.invoke('After', @scenario.with_result(result)) }
           Hooks.after_hook(source, hook.location, &action)
-        end          
+        end
       end
     end
   end

data/lib/cucumber/runtime/for_programming_languages.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 require 'forwardable'
 require 'cucumber/core/ast/doc_string'
-require 'cucumber/core/ast/data_table'
 
 module Cucumber
   class Runtime
@@ -27,41 +26,7 @@ module Cucumber
 
       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
+        :invoke_dynamic_step
     end
   end
 end

data/lib/cucumber/runtime/support_code.rb

@@ -4,7 +4,6 @@ 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'
 
@@ -31,7 +30,9 @@ module Cucumber
         end
 
         def multiline_arg(step, location)
-          if argument = step[:argument]
+          argument = step[:argument]
+
+          if argument
             if argument[:type] == :DocString
               MultilineArgument.doc_string(argument[:content], argument[:content_type], location)
             else
@@ -45,11 +46,13 @@ module Cucumber
 
       include Constantize
 
-      attr_reader :ruby
+      attr_reader :registry
+
       def initialize(user_interface, configuration=Configuration.default)
         @configuration = configuration
+        # TODO: needs a better name, or inlining its methods
         @runtime_facade = Runtime::ForProgrammingLanguages.new(self, user_interface)
-        @ruby = Cucumber::RbSupport::RbLanguage.new(@runtime_facade, @configuration)
+        @registry = Cucumber::Glue::RegistryAndMore.new(@runtime_facade, @configuration)
       end
 
       def configure(new_configuration)
@@ -62,7 +65,7 @@ module Cucumber
       #     Given I have 8 cukes in my belly
       #     Then I should not be thirsty
       #   })
-      def invoke_dynamic_steps(steps_text, i18n, location)
+      def invoke_dynamic_steps(steps_text, i18n, _location)
         parser = Cucumber::Gherkin::StepsParser.new(StepInvoker.new(self), i18n.iso_code)
         parser.parse(steps_text)
       end
@@ -73,7 +76,7 @@ module Cucumber
       # 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)
+      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)
@@ -93,39 +96,40 @@ module Cucumber
       end
 
       def unmatched_step_definitions
-        @ruby.unmatched_step_definitions
+        registry.unmatched_step_definitions
       end
 
       def fire_hook(name, *args)
-        @ruby.send(name, *args)
+        # TODO: kill with fire
+        registry.send(name, *args)
       end
 
       def step_definitions
-        @ruby.step_definitions
+        registry.step_definitions
       end
 
       def find_after_step_hooks(test_case)
         scenario = RunningTestCase.new(test_case)
-        hooks = @ruby.hooks_for(:after_step, scenario)
+        hooks = registry.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)
+        hooks = registry.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)
+        hooks = registry.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|
+        registry.hooks_for(:around, scenario).map do |hook|
           Hooks.around_hook(test_case.source) do |run_scenario|
             hook.invoke('Around', scenario, &run_scenario)
           end
@@ -135,12 +139,12 @@ module Cucumber
       private
 
       def step_matches(step_name)
-        StepMatchSearch.new(@ruby.method(:step_matches), @configuration).call(step_name)
+        StepMatchSearch.new(registry.method(:step_matches), @configuration).call(step_name)
       end
 
       def load_file(file)
         log.debug("  * #{file}\n")
-        @ruby.load_code_file(file)
+        registry.load_code_file(file)
       end
 
       def log

data/lib/cucumber/runtime/user_interface.rb

@@ -7,10 +7,6 @@ module Cucumber
     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)
@@ -43,12 +39,9 @@ module Cucumber
           answer = mri_gets(timeout_seconds)
         end
 
-        if(answer)
-          puts(answer)
-          answer
-        else
-          raise("Waited for input for #{timeout_seconds} seconds, then timed out.")
-        end
+        raise("Waited for input for #{timeout_seconds} seconds, then timed out.") unless answer
+        puts(answer)
+        answer
       end
 
       # Embed +src+ of MIME type +mime_type+ into the output. The +src+ argument may
@@ -59,7 +52,7 @@ module Cucumber
         @visitor.embed(src, mime_type, label)
       end
 
-    private
+      private
 
       def mri_gets(timeout_seconds)
         begin

data/lib/cucumber/step_argument.rb

@@ -12,8 +12,6 @@ module Cucumber
           offset = match.offset(n)[0]
           new(offset, val)
         end
-      else
-        nil
       end
     end
 

data/lib/cucumber/step_definition_light.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 module Cucumber
+  # TODO: pointless, ancient, kill with fire.
   # 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).

data/lib/cucumber/step_match.rb

@@ -13,7 +13,7 @@ module Cucumber
     end
 
     def args
-      @step_arguments.map{|g| g.val }
+      @step_arguments.map{|g| g.value }
     end
 
     def activate(test_step)
@@ -56,30 +56,31 @@ module Cucumber
     end
 
     def backtrace_line
-      "#{file_colon_line}:in `#{@step_definition.regexp_source}'"
+      "#{file_colon_line}:in `#{@step_definition.expression}'"
     end
 
     def text_length
-      @step_definition.regexp_source.unpack('U*').length
+      @step_definition.expression.source.to_s.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
+        group = step_argument.group
+        next if group.value.nil? || group.start < 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
+                        proc.call(group.value)
+                      elsif Proc === format
+                        format.call(group.value)
+                      else
+                        format % group.value
+                      end
+
+        s[group.start + offset, group.value.length] = replacement
+        offset += replacement.unpack('U*').length - group.value.unpack('U*').length
+        past_offset = group.start + group.value.length
       end
       s
     end
@@ -108,7 +109,7 @@ module Cucumber
       @name = name
     end
 
-    def format_args(*args)
+    def format_args(*_args)
       @name
     end
 

data/lib/cucumber/step_match_search.rb

@@ -33,8 +33,8 @@ module Cucumber
 
       private
 
-      def best_matches(step_name, step_matches) #:nodoc:
-        no_groups      = step_matches.select {|step_match| step_match.args.length == 0}
+      def best_matches(_step_name, step_matches) #:nodoc:
+        no_groups      = step_matches.select {|step_match| step_match.args.empty?}
         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 }
 
@@ -65,4 +65,3 @@ module Cucumber
 
   end
 end
-

data/lib/cucumber/term/ansicolor.rb

@@ -33,7 +33,7 @@ module Cucumber
         [ :on_blue      ,  44 ],
         [ :on_magenta   ,  45 ],
         [ :on_cyan      ,  46 ],
-        [ :on_white     ,  47 ],
+        [ :on_white     ,  47 ]
       ]
 
       ATTRIBUTE_NAMES = ATTRIBUTES.transpose.first

data/lib/cucumber/version

@@ -1 +1 @@
-3.0.0.pre.1
+3.0.0.pre.2

data/lib/simplecov_setup.rb

@@ -14,6 +14,6 @@ if ENV['SIMPLECOV']
       add_filter '/features/'
     end
   rescue LoadError
-    warn("Unable to load simplecov")
+    warn('Unable to load simplecov')
   end
 end

data/scripts/invite-collaborator

@@ -0,0 +1,40 @@
+#!/usr/bin/env ruby
+require 'octokit'
+
+class Team
+  attr_reader :gh, :name
+
+  def initialize(gh, name)
+    @gh = gh
+    @name = name
+  end
+
+  def add_member(login)
+    gh.add_team_membership(id, login)
+  end
+
+  def id
+    team['id']
+  end
+
+  def team
+    @team ||= gh.organization_teams('cucumber').
+      find { |team| team['name'] == name } || raise("Unable to find a team named #{name}")
+  end
+end
+
+begin
+  token = ENV['GITHUB_TOKEN'] || raise('You need to set GITHUB_TOKEN')
+  login = (ARGV[0] || raise("syntax: #{$0} <COLLABORATOR_LOGIN>")).to_s
+
+  gh = Octokit::Client.new(access_token: token)
+  [
+    Team.new(gh, 'cucumber-ruby'),
+    Team.new(gh, 'collaborators')
+  ].each { |team|
+    team.add_member(login)
+  }
+
+rescue StandardError => error
+  abort error.message
+end

data/scripts/update-history

@@ -0,0 +1,83 @@
+#!/usr/bin/env ruby
+require 'octokit'
+
+class PullRequest
+  attr_reader :gh, :num
+
+  def initialize(gh, num)
+    @gh = gh
+    @num = num
+  end
+
+  def entry
+    pr = gh.pull_request('cucumber/cucumber-ruby', num)
+    "#{pr['title']} ([##{num}(#{pr['url']}) @#{pr['user']['login']})"
+  end
+
+  def labels
+    gh.labels_for_issue('cucumber/cucumber-ruby', num).map { |label| label['name'] }
+  end
+
+  def type_label
+    types = labels.select { |label| label =~ /^type: / }
+    if types.empty?
+      raise('This pull request does not have a \'type\' label on it. Please add one.')
+    end
+
+    if types.length > 1
+      raise('This pull request has more than one \'type\' label on it. Please choose just one.')
+    end
+
+    types.first
+  end
+end
+
+class HistoryFile
+  def self.open(path, &block)
+    full_path = File.expand_path(File.dirname(__FILE__) + '/' + path + '/History.md')
+    history = new(File.read(full_path))
+    history.instance_exec(&block)
+    File.write(full_path, history.body)
+  end
+
+  attr_reader :lines
+
+  def initialize(body)
+    @lines = body.lines
+  end
+
+  def insert(label, entry)
+    section_index = lines.index { |line| line.strip == heading_for(label) }
+    unless section_index
+      raise("Unable to find matching heading in History.md for '#{label}' (#{heading_for(label)})")
+    end
+    lines.insert(section_index + 2, "* #{entry}\n")
+  end
+
+  def heading_for(label)
+    text = {
+      'type: new feature' => 'New Features',
+      'type: bug' => 'Bugfixes',
+      'type: refactoring / developer experience' => 'Refactoring / Developer Experience'
+    }.fetch(label)
+    "### #{text}"
+  end
+
+  def body
+    lines.join
+  end
+end
+
+begin
+  token = ENV['GITHUB_TOKEN'] || raise('You need to set GITHUB_TOKEN')
+  num = (ARGV[0] || raise("syntax: #{$0} <PULL-REQUEST-NUMBER>")).to_i
+
+  gh = Octokit::Client.new(access_token: token)
+  pr = PullRequest.new(gh, num)
+
+  HistoryFile.open('..') do
+    insert(pr.type_label, pr.entry)
+  end
+rescue StandardError => error
+  abort error.message
+end