cucumber-cucumber-expressions 8.3.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d75b7265f9a2c2142d7733b064bb4e6ec6d317d1f32ba9e4148e42512b90a4df
+  data.tar.gz: c7f8fa3ce1e9eccaf40fcbfd9288ed8302ea1b13b2cb8aa385a64abaf94a2d15
+SHA512:
+  metadata.gz: a05e6facfd23519c59b261e253a623097c892108a9b66d3fd330128b9651be4923f01b16666cf61c82abc112c6b5fcee987703b0c4198462148b6a174b51ba24
+  data.tar.gz: '09a81cd8ef765626765d0f269063c284266cf2153d3b80c4cdeacb464aeea41b4df9967ba256a3f8a27bd06f89c2f650cffffc903e4d5206504e05ff1daa2e50'

data/.github/ISSUE_TEMPLATE.md

@@ -0,0 +1,5 @@
+PLEASE DO NOT CREATE ISSUES IN THIS REPO.
+THIS REPO IS A READ-ONLY MIRROR.
+
+Create your issue in the Cucumber monorepo instead:
+https://github.com/cucumber/cucumber/issues

data/.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,5 @@
+PLEASE DO NOT CREATE PULL REAUESTS IN THIS REPO.
+THIS REPO IS A READ-ONLY MIRROR.
+
+Create your pull request in the Cucumber monorepo instead:
+https://github.com/cucumber/cucumber/pulls

data/.rspec

@@ -0,0 +1 @@
+--color

data/.rsync

@@ -0,0 +1,4 @@
+../../LICENSE LICENSE
+../../.templates/github/ .github/
+../../.templates/ruby/ .
+../examples.txt examples.txt

data/.subrepo

@@ -0,0 +1 @@
+cucumber/cucumber-expressions-ruby

data/Gemfile

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+source "https://rubygems.org"
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) Cucumber Ltd
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/Makefile

@@ -0,0 +1 @@
+include default.mk

data/README.md

@@ -0,0 +1,5 @@
+# Cucumber Expressions for Ruby
+
+[![Build Status](https://travis-ci.org/cucumber/cucumber-expressions-ruby.svg?branch=master)](https://travis-ci.org/cucumber/cucumber-expressions-ruby)
+
+[The docs are here](https://cucumber.io/docs/cucumber/cucumber-expressions/).

data/Rakefile

@@ -0,0 +1,27 @@
+# encoding: utf-8
+require 'rubygems'
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+$:.unshift File.expand_path("../lib", __FILE__)
+
+Dir['./rake/*.rb'].each do |f|
+  require f
+end
+
+require "rspec/core/rake_task"
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.ruby_opts  = %w[-r./spec/coverage -w]
+end
+
+require_relative 'spec/capture_warnings'
+include CaptureWarnings
+namespace :spec do
+  task :warnings do
+    report_warnings do
+      Rake::Task['spec'].invoke
+    end
+  end
+end
+
+task default: ['spec:warnings']

data/cucumber-cucumber-expressions.gemspec

@@ -0,0 +1,33 @@
+# -*- encoding: utf-8 -*-
+Gem::Specification.new do |s|
+  s.name        = 'cucumber-cucumber-expressions'
+  s.version     = '8.3.1'
+  s.authors     = ["Aslak Hellesøy"]
+  s.description = 'Cucumber Expressions - a simpler alternative to Regular Expressions'
+  s.summary     = "cucumber-expressions-#{s.version}"
+  s.email       = 'cukes@googlegroups.com'
+  s.homepage    = "https://github.com/cucumber/cucumber-expressions-ruby#readme"
+  s.platform    = Gem::Platform::RUBY
+  s.license     = "MIT"
+  s.required_ruby_version = ">= 2.3"
+
+  s.metadata    = {
+                    'bug_tracker_uri'   => 'https://github.com/cucumber/cucumber/issues',
+                    'changelog_uri'     => 'https://github.com/cucumber/cucumber/blob/master/cucumber-expressions/CHANGELOG.md',
+                    'documentation_uri' => 'https://cucumber.io/docs/cucumber/cucumber-expressions/',
+                    'mailing_list_uri'  => 'https://groups.google.com/forum/#!forum/cukes',
+                    'source_code_uri'   => 'https://github.com/cucumber/cucumber/blob/master/cucumber-expressions/ruby',
+                  }
+
+  s.add_development_dependency 'rake', '~> 13.0', '>= 13.0.1'
+  s.add_development_dependency 'rspec', '~> 3.9', '>= 3.9.0'
+
+  # For coverage reports
+  s.add_development_dependency 'coveralls', '~> 0.8', '>= 0.8.23'
+
+  s.rubygems_version = ">= 1.6.1"
+  s.files            = `git ls-files`.split("\n").reject {|path| path =~ /\.gitignore$/ }
+  s.test_files       = `git ls-files -- spec/*`.split("\n")
+  s.rdoc_options     = ["--charset=UTF-8"]
+  s.require_path     = "lib"
+end

data/default.mk

@@ -0,0 +1,70 @@
+SHELL := /usr/bin/env bash
+RUBY_SOURCE_FILES = $(shell find . -name "*.rb")
+GEMSPEC = $(shell find . -name "*.gemspec")
+LIBNAME := $(shell basename $$(dirname $$(pwd)))
+GEM := cucumber-$(LIBNAME)-$(NEW_VERSION).gem
+
+default: .tested
+.PHONY: default
+
+.deps: Gemfile.lock
+	touch $@
+
+Gemfile.lock: Gemfile $(GEMSPEC)
+	bundle install
+	touch $@
+
+.tested: .deps $(RUBY_SOURCE_FILES)
+	bundle exec rspec --color
+	touch $@
+
+update-dependencies:
+	./scripts/update-gemspec
+.PHONY: update-dependencies
+
+ifdef NEW_VERSION
+ifneq (,$(GEMSPEC))
+gem: $(GEM)
+else
+gem:
+	@echo "Not building gem because there is no gemspec"
+endif
+endif
+.PHONY: gem
+
+$(GEM): clean .tested
+	gem build $(GEMSPEC)
+	test -s "$(GEM)" || { echo "Gem not built: $(GEM)"; exit 1; }
+
+pre-release: update-version update-dependencies gem
+.PHONY: pre-release
+
+update-version:
+ifdef NEW_VERSION
+ifneq (,$(GEMSPEC))
+	sed -i "s/\(s\.version *= *'\)[0-9]*\.[0-9]*\.[0-9]*\('\)/\1$(NEW_VERSION)\2/" $(GEMSPEC)
+endif
+else
+	@echo -e "\033[0;31mNEW_VERSION is not defined. Can't update version :-(\033[0m"
+	exit 1
+endif
+.PHONY: update-version
+
+publish: gem
+ifneq (,$(GEMSPEC))
+	gem push $(GEM)
+else
+	@echo "Not publishing because there is no gemspec"
+endif
+.PHONY: publish
+
+post-release:
+	@echo "No post-release needed for ruby"
+.PHONY: post-release
+
+clean: clean-ruby
+.PHONY: clean
+
+clean-ruby:
+	rm -f .deps .linked .tested* Gemfile.lock *.gem
+.PHONY: clean-ruby

data/examples.txt

@@ -0,0 +1,31 @@
+I have {int} cuke(s)
+I have 22 cukes
+[22]
+---
+I have {int} cuke(s) and some \[]^$.|?*+
+I have 1 cuke and some \[]^$.|?*+
+[1]
+---
+/I have (\d+) cukes? in my (\w+) now/
+I have 22 cukes in my belly now
+[22,"belly"]
+---
+/I have (-?\d+) cukes? in my (.*) now/
+I have 1 cuke in my belly now
+[1,"belly"]
+---
+/^Something( with an optional argument)?$/
+Something
+[null]
+---
+Привет, {word}!
+Привет, Мир!
+["Мир"]
+---
+/I have (.*) cukes? in my (.*) now/
+I have 22 cukes in my belly now
+["22","belly"]
+---
+I have {} cuke(s) in my {} now
+I have 22 cukes in my belly now
+["22","belly"]

data/lib/cucumber/cucumber_expressions/argument.rb

@@ -0,0 +1,37 @@
+require 'cucumber/cucumber_expressions/group'
+require 'cucumber/cucumber_expressions/errors'
+
+module Cucumber
+  module CucumberExpressions
+    class Argument
+      attr_reader :group, :parameter_type
+
+      def self.build(tree_regexp, text, parameter_types)
+        group = tree_regexp.match(text)
+        return nil if group.nil?
+
+        arg_groups = group.children
+
+        if arg_groups.length != parameter_types.length
+          raise CucumberExpressionError.new(
+              "Expression #{tree_regexp.regexp.inspect} has #{arg_groups.length} capture groups (#{arg_groups.map(&:value)}), but there were #{parameter_types.length} parameter types (#{parameter_types.map(&:name)})"
+          )
+        end
+
+        parameter_types.zip(arg_groups).map do |parameter_type, arg_group|
+          Argument.new(arg_group, parameter_type)
+        end
+      end
+
+      def initialize(group, parameter_type)
+        @group, @parameter_type = group, parameter_type
+      end
+
+      def value(self_obj=:nil)
+        raise "No self_obj" if self_obj == :nil
+        group_values = @group ? @group.values : nil
+        @parameter_type.transform(self_obj, group_values)
+      end
+    end
+  end
+end

data/lib/cucumber/cucumber_expressions/combinatorial_generated_expression_factory.rb

@@ -0,0 +1,49 @@
+require('cucumber/cucumber_expressions/generated_expression')
+
+module Cucumber
+  module CucumberExpressions
+
+    class CombinatorialGeneratedExpressionFactory
+      def initialize(expression_template, parameter_type_combinations)
+        @expression_template = expression_template
+        @parameter_type_combinations = parameter_type_combinations
+      end
+
+      def generate_expressions
+        generated_expressions = []
+        generate_permutations(generated_expressions, 0, [])
+        generated_expressions
+      end
+
+      # 256 generated expressions ought to be enough for anybody
+      MAX_EXPRESSIONS = 256
+
+      def generate_permutations(generated_expressions, depth, current_parameter_types)
+        if generated_expressions.length >= MAX_EXPRESSIONS
+          return
+        end
+
+        if depth == @parameter_type_combinations.length
+          generated_expression = GeneratedExpression.new(@expression_template, current_parameter_types)
+          generated_expressions.push(generated_expression)
+          return
+        end
+
+        (0...@parameter_type_combinations[depth].length).each do |i|
+          # Avoid recursion if no elements can be added.
+          if generated_expressions.length >= MAX_EXPRESSIONS
+            return
+          end
+          new_current_parameter_types = current_parameter_types.dup # clone
+          new_current_parameter_types.push(@parameter_type_combinations[depth][i])
+          generate_permutations(
+              generated_expressions,
+              depth + 1,
+              new_current_parameter_types
+          )
+        end
+      end
+    end
+
+  end
+end

data/lib/cucumber/cucumber_expressions/cucumber_expression.rb

@@ -0,0 +1,119 @@
+require 'cucumber/cucumber_expressions/argument'
+require 'cucumber/cucumber_expressions/tree_regexp'
+require 'cucumber/cucumber_expressions/errors'
+
+module Cucumber
+  module CucumberExpressions
+    class CucumberExpression
+      # Does not include (){} characters because they have special meaning
+      ESCAPE_REGEXP = /([\\^\[$.|?*+\]])/
+      PARAMETER_REGEXP = /(\\\\)?{([^}]*)}/
+      OPTIONAL_REGEXP = /(\\\\)?\(([^)]+)\)/
+      ALTERNATIVE_NON_WHITESPACE_TEXT_REGEXP = /([^\s^\/]+)((\/[^\s^\/]+)+)/
+      DOUBLE_ESCAPE = '\\\\'
+      PARAMETER_TYPES_CANNOT_BE_ALTERNATIVE = 'Parameter types cannot be alternative: '
+      PARAMETER_TYPES_CANNOT_BE_OPTIONAL = 'Parameter types cannot be optional: '
+
+      attr_reader :source
+
+      def initialize(expression, parameter_type_registry)
+        @source = expression
+        @parameter_types = []
+
+        expression = process_escapes(expression)
+        expression = process_optional(expression)
+        expression = process_alternation(expression)
+        expression = process_parameters(expression, parameter_type_registry)
+        expression = "^#{expression}$"
+
+        @tree_regexp = TreeRegexp.new(expression)
+      end
+
+      def match(text)
+        Argument.build(@tree_regexp, text, @parameter_types)
+      end
+
+      def regexp
+        @tree_regexp.regexp
+      end
+
+      def to_s
+        @source.inspect
+      end
+
+      private
+
+      def process_escapes(expression)
+        expression.gsub(ESCAPE_REGEXP, '\\\\\1')
+      end
+
+      def process_optional(expression)
+        # Create non-capturing, optional capture groups from parenthesis
+        expression.gsub(OPTIONAL_REGEXP) do
+          g2 = $2
+          # When using Parameter Types, the () characters are used to represent an optional
+          # item such as (a ) which would be equivalent to (?:a )? in regex
+          #
+          # You cannot have optional Parameter Types i.e. ({int}) as this causes
+          # problems during the conversion phase to regex. So we check for that here
+          #
+          # One exclusion to this rule is if you actually want the brackets i.e. you
+          # want to capture (3) then we still permit this as an individual rule
+          # See: https://github.com/cucumber/cucumber-ruby/issues/1337 for more info
+          # look for double-escaped parentheses
+          if $1 == DOUBLE_ESCAPE
+            "\\(#{g2}\\)"
+          else
+            check_no_parameter_type(g2, PARAMETER_TYPES_CANNOT_BE_OPTIONAL)
+            "(?:#{g2})?"
+          end
+        end
+      end
+
+      def process_alternation(expression)
+        expression.gsub(ALTERNATIVE_NON_WHITESPACE_TEXT_REGEXP) do
+          # replace \/ with /
+          # replace / with |
+          replacement = $&.tr('/', '|').gsub(/\\\|/, '/')
+          if replacement.include?('|')
+            replacement.split(/\|/).each do |part|
+              check_no_parameter_type(part, PARAMETER_TYPES_CANNOT_BE_ALTERNATIVE)
+            end
+            "(?:#{replacement})"
+          else
+            replacement
+          end
+        end
+      end
+
+      def process_parameters(expression, parameter_type_registry)
+        # Create non-capturing, optional capture groups from parenthesis
+        expression.gsub(PARAMETER_REGEXP) do
+          if ($1 == DOUBLE_ESCAPE)
+            "\\{#{$2}\\}"
+          else
+            type_name = $2
+            ParameterType.check_parameter_type_name(type_name)
+            parameter_type = parameter_type_registry.lookup_by_type_name(type_name)
+            raise UndefinedParameterTypeError.new(type_name) if parameter_type.nil?
+            @parameter_types.push(parameter_type)
+
+            build_capture_regexp(parameter_type.regexps)
+          end
+        end
+      end
+
+      def build_capture_regexp(regexps)
+        return "(#{regexps[0]})" if regexps.size == 1
+        capture_groups = regexps.map { |group| "(?:#{group})" }
+        "(#{capture_groups.join('|')})"
+      end
+
+      def check_no_parameter_type(s, message)
+        if PARAMETER_REGEXP =~ s
+          raise CucumberExpressionError.new("#{message}#{source}")
+        end
+      end
+    end
+  end
+end