cucumber-expressions 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 20e3d4346c870de1268b51167007be59e26ca973
+  data.tar.gz: 0ff8f397d739c309bea2a8ee27e87dea441d0320
+SHA512:
+  metadata.gz: 4badd619f8dcf0ffe6da3a62515776f3c2d482955e948b7ad47d475e2124638e3aeb3e177ad9e99bfe30c703663bec5511777486f1c666b1764d834371acd473
+  data.tar.gz: c707a12743cd5c77e49332b88d9d8b8f99a3f72ee8cd0bd019a85fa067f7eee3d33c4d693132fcba61efa5d8770ff88677815f3c192a56edfa2e680245d83a5b

data/.rspec

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

data/.travis.yml

@@ -0,0 +1,20 @@
+# manyrepo: cucumber/cucumber-expressions-ruby
+language: ruby
+sudo: false
+
+rvm:
+  - 2.3.1
+  - 2.2
+  - 2.1
+  - 2.0
+  - jruby-9.1.2.0
+
+before_install:
+  - gem update bundler
+
+notifications:
+  email:
+    - cukes-devs@googlegroups.com
+  webhooks:
+    urls: # gitter
+      - https://webhooks.gitter.im/e/dc010332f9d40fcc21c4

data/Gemfile

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

data/Makefile

@@ -0,0 +1,9 @@
+LICENSE: ../../LICENSE
+	cp $< $@
+
+.PHONY: release
+release:
+	bundle exec rake build release:guard_clean release:rubygem_push
+	version=$$(cat *.gemspec | grep -m 1 ".version *= *" | sed "s/.*= *'\([^']*\)'.*/\1/"); \
+	git tag --annotate v$$version --message "Release $$version"
+	git push --tags

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](http://docs.cucumber.io/cucumber-expressions/).

data/Rakefile

@@ -0,0 +1,23 @@
+# encoding: utf-8
+require 'rubygems'
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+$:.unshift File.expand_path("../lib", __FILE__)
+
+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-expressions.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+Gem::Specification.new do |s|
+  s.name        = 'cucumber-expressions'
+  s.version     = '1.0.0'
+  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://cucumber.io/"
+  s.platform    = Gem::Platform::RUBY
+  s.license     = "MIT"
+  s.required_ruby_version = ">= 1.9.3"
+
+  s.add_development_dependency 'bundler',   '>= 1.12.5'
+  s.add_development_dependency 'rake',      '>= 10.5.0'
+  s.add_development_dependency 'rspec',     '~> 3.5'
+  s.add_development_dependency 'json',     '~> 2.0.2'
+
+  # For coverage reports
+  s.add_development_dependency 'coveralls', '~> 0.7'
+
+  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/examples.txt

@@ -0,0 +1,15 @@
+I have {n} cuke(s) in my {bodypart} now
+I have 22 cukes in my belly now
+["22","belly"]
+---
+I have {n:int} cuke(s) in my {bodypart} now
+I have 1 cuke in my belly now
+[1,"belly"]
+---
+/I have (\d+) cukes? in my (.+) 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"]

data/lib/cucumber/cucumber_expressions/argument.rb

@@ -0,0 +1,11 @@
+module Cucumber
+  module CucumberExpressions
+    class Argument
+      attr_reader :offset, :value, :transformed_value
+
+      def initialize(offset, value, transformed_value)
+        @offset, @value, @transformed_value = offset, value, transformed_value
+      end
+    end
+  end
+end

data/lib/cucumber/cucumber_expressions/argument_matcher.rb

@@ -0,0 +1,18 @@
+require 'cucumber/cucumber_expressions/argument'
+
+module Cucumber
+  module CucumberExpressions
+    class ArgumentMatcher
+      def self.match_arguments(regexp, text, transforms)
+        m = regexp.match(text)
+        return nil if m.nil?
+        (1...m.length).map do |index|
+          value = m[index]
+          transform = transforms[index-1]
+          transformed_value = transform.transform(value)
+          Argument.new(m.offset(index)[0], value, transformed_value)
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/cucumber_expressions/cucumber_expression.rb

@@ -0,0 +1,63 @@
+require 'cucumber/cucumber_expressions/argument_matcher'
+require 'cucumber/cucumber_expressions/transform'
+
+module Cucumber
+  module CucumberExpressions
+    class CucumberExpression
+      PARAMETER_PATTERN = /\{([^}:]+)(:([^}]+))?}/
+      OPTIONAL_PATTERN = /\(([^\)]+)\)/
+
+      attr_reader :source
+
+      def initialize(expression, types, transform_lookup)
+        @source = expression
+        @transforms = []
+        regexp = "^"
+        type_index = 0
+        match = nil
+        match_offset = 0
+
+        # Create non-capturing, optional capture groups from parenthesis
+        expression = expression.gsub(OPTIONAL_PATTERN, '(?:\1)?')
+
+        loop do
+          match = PARAMETER_PATTERN.match(expression, match_offset)
+          break if match.nil?
+
+          parameter_name = match[1]
+          type_name = match[3]
+          type = types.length <= type_index ? nil : types[type_index]
+          type_index += 1
+
+          transform = nil
+          if (type)
+            transform = transform_lookup.lookup_by_type(type)
+          end
+          if (transform.nil? && type_name)
+            transform = transform_lookup.lookup_by_type_name(type_name, false)
+          end
+          if (transform.nil?)
+            transform = transform_lookup.lookup_by_type_name(parameter_name, true)
+          end
+          if (transform.nil?)
+            transform = transform_lookup.create_anonymous_lookup(lambda {|s| s})
+          end
+          @transforms.push(transform)
+
+          text = expression.slice(match_offset...match.offset(0)[0])
+          capture_regexp = "(#{transform.capture_group_regexps[0]})"
+          match_offset = match.offset(0)[1]
+          regexp += text
+          regexp += capture_regexp
+        end
+        regexp += expression.slice(match_offset..-1)
+        regexp += "$"
+        @regexp = Regexp.new(regexp)
+      end
+
+      def match(text)
+        ArgumentMatcher.match_arguments(@regexp, text, @transforms)
+      end
+    end
+  end
+end

data/lib/cucumber/cucumber_expressions/cucumber_expression_generator.rb

@@ -0,0 +1,76 @@
+require 'cucumber/cucumber_expressions/transform_matcher'
+require 'cucumber/cucumber_expressions/generated_expression'
+
+module Cucumber
+  module CucumberExpressions
+    class CucumberExpressionGenerator
+      def initialize(transform_lookup)
+        @transform_lookup = transform_lookup
+      end
+
+      def generate_expression(text, typed)
+        transform_matchers = create_transform_matchers(text)
+        transforms = []
+
+        expression = ""
+        arg_counter = 0
+        pos = 0
+
+        loop do
+          matching_transform_matchers = []
+          transform_matchers.each do |transform_matcher|
+            advanced_transform_matcher = transform_matcher.advance_to(pos)
+            if advanced_transform_matcher.find
+              matching_transform_matchers.push(advanced_transform_matcher)
+            end
+          end
+
+          if matching_transform_matchers.any?
+            matching_transform_matchers = matching_transform_matchers.sort
+            best_transform_matcher = matching_transform_matchers[0]
+            transforms.push(best_transform_matcher.transform)
+
+            expression += text.slice(pos...best_transform_matcher.start)
+            expression += "{arg#{arg_counter += 1}"
+
+            if typed
+              expression += ":#{best_transform_matcher.transform.type_name}"
+            end
+            expression += "}"
+            pos = best_transform_matcher.start + best_transform_matcher.group.length
+          else
+            break
+          end
+
+          if pos >= text.length
+            break
+          end
+        end
+
+        expression += text.slice(pos..-1)
+        GeneratedExpression.new(expression, transforms)
+      end
+
+    private
+
+      def create_transform_matchers(text)
+        transform_matchers = []
+        @transform_lookup.transforms.each do |transform|
+          transform_matchers += create_transform_matchers2(transform, text)
+        end
+        transform_matchers
+      end
+
+      def create_transform_matchers2(transform, text)
+        result = []
+        capture_group_regexps = transform.capture_group_regexps
+        capture_group_regexps.each do |capture_group_regexp|
+          regexp = Regexp.new("(#{capture_group_regexp})")
+          result.push(TransformMatcher.new(transform, regexp, text))
+        end
+        result
+      end
+
+    end
+  end
+end

data/lib/cucumber/cucumber_expressions/generated_expression.rb

@@ -0,0 +1,11 @@
+module Cucumber
+  module CucumberExpressions
+    class GeneratedExpression
+      attr_reader :source, :transforms
+
+      def initialize(source, transforms)
+        @source, @transforms = source, transforms
+      end
+    end
+  end
+end

data/lib/cucumber/cucumber_expressions/regular_expression.rb

@@ -0,0 +1,49 @@
+require 'cucumber/cucumber_expressions/argument_matcher'
+
+module Cucumber
+  module CucumberExpressions
+    class RegularExpression
+      CAPTURE_GROUP_PATTERN = /\(([^(]+)\)/
+
+      def initialize(regexp, types, transform_lookup)
+        @regexp = regexp
+        @transforms = []
+
+        type_index = 0
+        match = nil
+        match_offset = 0
+
+        loop do
+          match = CAPTURE_GROUP_PATTERN.match(regexp.source, match_offset)
+          break if match.nil?
+
+          capture_group_pattern = match[1]
+          type = types.length <= type_index ? nil : types[type_index]
+          type_index += 1
+
+          transform = nil
+          if (type)
+            transform = transform_lookup.lookup_by_type(type)
+          end
+          if (transform.nil?)
+            transform = transform_lookup.lookup_by_capture_group_regexp(capture_group_pattern)
+          end
+          if (transform.nil?)
+            transform = transform_lookup.create_anonymous_lookup(lambda {|s| s})
+          end
+
+          @transforms.push(transform)
+          match_offset = match.offset(0)[1]
+        end
+      end
+
+      def match(text)
+        ArgumentMatcher.match_arguments(@regexp, text, @transforms)
+      end
+
+      def source
+        @regexp
+      end
+    end
+  end
+end

data/lib/cucumber/cucumber_expressions/transform.rb

@@ -0,0 +1,25 @@
+module Cucumber
+  module CucumberExpressions
+    class Transform
+      attr_reader :type_name, :type, :capture_group_regexps
+
+      # Create a new Transform
+      #
+      # @param type_name [Array] array of class or type name to use in {arg:type_name}
+      # @param capture_group_regexps [Array] list of regexps for capture groups.
+      #   The first one is the primary one, used to convert CucumberExpression instances
+      #   to their internal Regexp representation. They are all used for type conversion
+      #   in RegularExpression instances.
+      # @transformer lambda that transforms a String to another type
+      #
+      def initialize(type_name, type, capture_group_regexps, transformer)
+        @type_name, @type, @transformer = type_name, type, transformer
+        @capture_group_regexps = capture_group_regexps.is_a?(String) ? [capture_group_regexps] : capture_group_regexps
+      end
+
+      def transform(value)
+        @transformer.call(value)
+      end
+    end
+  end
+end

data/lib/cucumber/cucumber_expressions/transform_lookup.rb

@@ -0,0 +1,70 @@
+require 'cucumber/cucumber_expressions/transform'
+
+module Cucumber
+  module CucumberExpressions
+    class TransformLookup
+      FIXNUM_REGEXPS = ['-?\d+', '\d+']
+      FLOATING_POINT_REGEXPS = ['-?\d*\.?\d+']
+
+      def initialize
+        @transforms_by_type_name = {}
+        @transforms_by_capture_group_regexp = {}
+        @transforms_by_class = {}
+
+        add_transform(Transform.new('int', Fixnum, FIXNUM_REGEXPS, lambda {|s| s.to_i}))
+        add_transform(Transform.new('float', Float, FLOATING_POINT_REGEXPS, lambda {|s| s.to_f}))
+      end
+
+      def lookup_by_type(type)
+        if type.is_a?(Class)
+          lookup_by_class(type)
+        elsif type.is_a?(String)
+          lookup_by_type_name(type, false)
+        else
+          raise Exception.new("Type must be string or class, but was #{type} of type #{type.class}")
+        end
+      end
+
+      def lookup_by_class(clazz)
+        transform = @transforms_by_class[clazz]
+        if transform.nil?
+          create_anonymous_lookup(lambda {|s| clazz.new(s)})
+        else
+          transform
+        end
+      end
+
+      def lookup_by_type_name(type_name, ignore_unknown_type_name)
+        transform = @transforms_by_type_name[type_name]
+        if transform.nil?
+          return nil if ignore_unknown_type_name
+          raise Exception.new("No transform for type name \"#{type_name}\"")
+        else
+          transform
+        end
+      end
+
+      def lookup_by_capture_group_regexp(capture_group_regexp)
+        @transforms_by_capture_group_regexp[capture_group_regexp]
+      end
+
+      def create_anonymous_lookup(proc)
+        Transform.new(nil, nil, ['.+'], proc)
+      end
+
+      def add_transform(transform)
+        @transforms_by_type_name[transform.type_name] = transform
+        @transforms_by_class[transform.type] = transform
+
+        transform.capture_group_regexps.each do |capture_group_regexp|
+          @transforms_by_capture_group_regexp[capture_group_regexp] = transform
+        end
+      end
+
+      def transforms
+        @transforms_by_type_name.values
+      end
+
+    end
+  end
+end

data/lib/cucumber/cucumber_expressions/transform_matcher.rb

@@ -0,0 +1,36 @@
+module Cucumber
+  module CucumberExpressions
+    class TransformMatcher
+      attr_reader :transform
+
+      def initialize(transform, regexp, text, match_position=0)
+        @transform, @regexp, @text = transform, regexp, text
+        @match = @regexp.match(@text, match_position)
+      end
+
+      def advance_to(new_match_position)
+        self.class.new(@transform, @regexp, @text, new_match_position)
+      end
+
+      def find
+        !@match.nil?
+      end
+
+      def start
+        @match.begin(0)
+      end
+
+      def group
+        @match.captures[0]
+      end
+
+      def <=>(other)
+        pos_comparison = start <=> other.start
+        return pos_comparison if pos_comparison != 0
+        length_comparison = other.group.length <=> group.length
+        return length_comparison if length_comparison != 0
+        0
+      end
+    end
+  end
+end

data/spec/capture_warnings.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+# With thanks to @myronmarston
+# https://github.com/vcr/vcr/blob/master/spec/capture_warnings.rb
+
+module CaptureWarnings
+  def report_warnings(&block)
+    current_dir = Dir.pwd
+    warnings, errors = capture_error(&block).partition { |line| line.include?('warning') }
+    project_warnings, other_warnings = warnings.uniq.partition { |line| line.include?(current_dir) }
+
+    if errors.any?
+      puts errors.join("\n")
+    end
+
+    if other_warnings.any?
+      puts "#{ other_warnings.count } non-cucumber-core warnings detected, set VIEW_OTHER_WARNINGS=true to see them."
+      print_warnings('other', other_warnings) if ENV['VIEW_OTHER_WARNINGS']
+    end
+
+    # Until they fix https://bugs.ruby-lang.org/issues/10661
+    if RUBY_VERSION == "2.2.0"
+      project_warnings = project_warnings.reject { |w| w =~ /warning: possible reference to past scope/ }
+    end
+
+    if project_warnings.any?
+      puts "#{ project_warnings.count } cucumber-core warnings detected"
+      print_warnings('cucumber-core', project_warnings)
+      fail "Please remove all cucumber-core warnings."
+    end
+
+    ensure_system_exit_if_required
+  end
+
+  def capture_error(&block)
+    old_stderr = STDERR.clone
+    pipe_r, pipe_w = IO.pipe
+    pipe_r.sync    = true
+    error         = String.new
+    reader = Thread.new do
+      begin
+        loop do
+          error << pipe_r.readpartial(1024)
+        end
+      rescue EOFError
+      end
+    end
+    STDERR.reopen(pipe_w)
+    block.call
+  ensure
+    capture_system_exit
+    STDERR.reopen(old_stderr)
+    pipe_w.close
+    reader.join
+    return error.split("\n")
+  end
+
+  def print_warnings(type, warnings)
+    puts
+    puts "-" * 30 + " #{type} warnings: " + "-" * 30
+    puts
+    puts warnings.join("\n")
+    puts
+    puts "-" * 75
+    puts
+  end
+
+  def ensure_system_exit_if_required
+    raise @system_exit if @system_exit
+  end
+
+  def capture_system_exit
+    @system_exit = $!
+  end
+end

data/spec/coverage.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+require 'simplecov'
+formatters = [ SimpleCov::Formatter::HTMLFormatter ]
+
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new(*formatters)
+SimpleCov.start

data/spec/cucumber/cucumber_expressions/cucumber_expression_generator_spec.rb

@@ -0,0 +1,77 @@
+require 'cucumber/cucumber_expressions/cucumber_expression_generator'
+require 'cucumber/cucumber_expressions/transform'
+require 'cucumber/cucumber_expressions/transform_lookup'
+
+module Cucumber
+  module CucumberExpressions
+    describe CucumberExpressionGenerator do
+      class Currency
+      end
+
+      before do
+        @transform_lookup = TransformLookup.new
+        @generator = CucumberExpressionGenerator.new(@transform_lookup)
+      end
+
+      it "documents expression generation" do
+        transform_lookup = TransformLookup.new
+        ### [generate-expression]
+        generator = CucumberExpressionGenerator.new(transform_lookup)
+        undefined_step_text = "I have 2 cucumbers and 1.5 tomato"
+        generated_expression = generator.generate_expression(undefined_step_text, true)
+        expect(generated_expression.source).to eq("I have {arg1:int} cucumbers and {arg2:float} tomato")
+        expect(generated_expression.transforms[1].type).to eq(Float)
+        ### [generate-expression]
+      end
+
+      it "generates expression for no args" do
+        assert_typed_expression("hello", "hello")
+      end
+
+      it "generates expression for int double arg" do
+        assert_typed_expression(
+          "I have {arg1:int} cukes and {arg2:float} euro",
+          "I have 2 cukes and 1.5 euro")
+      end
+
+      it "generates expression for just int" do
+        assert_typed_expression(
+          "{arg1:int}",
+          "99999")
+      end
+
+      it "generates expression without expression type" do
+        assert_untyped_expression(
+          "I have {arg1} cukes and {arg2} euro",
+          "I have 2 cukes and 1.5 euro")
+      end
+
+      it "generates expression for custom type" do
+        @transform_lookup.add_transform(Transform.new(
+          'currency',
+          Currency,
+          '[A-Z]{3}',
+          nil
+        ))
+
+        assert_typed_expression(
+          "I have a {arg1:currency} account",
+          "I have a EUR account")
+      end
+
+      it "exposes transforms in generated expression" do
+        expression = @generator.generate_expression("I have 2 cukes and 1.5 euro", true)
+        types = expression.transforms.map(&:type)
+        expect(types).to eq([Fixnum, Float])
+      end
+
+      def assert_typed_expression(expected, text)
+        expect(@generator.generate_expression(text, true).source).to eq(expected)
+      end
+
+      def assert_untyped_expression(expected, text)
+        expect(@generator.generate_expression(text, false).source).to eq(expected)
+      end
+    end
+  end
+end

data/spec/cucumber/cucumber_expressions/cucumber_expression_regexp_spec.rb

@@ -0,0 +1,43 @@
+require 'cucumber/cucumber_expressions/cucumber_expression'
+require 'cucumber/cucumber_expressions/transform_lookup'
+
+module Cucumber
+  module CucumberExpressions
+    describe CucumberExpression do
+      context "Regexp translation" do
+        def assert_regexp(expression, regexp)
+          cucumber_expression = CucumberExpression.new(expression, [], TransformLookup.new)
+          expect(regexp).to eq(cucumber_expression.instance_variable_get('@regexp'))
+        end
+
+        it "translates no arguments" do
+          assert_regexp(
+            "I have 10 cukes in my belly now",
+            /^I have 10 cukes in my belly now$/
+          )
+        end
+
+        it "translates two untyped arguments" do
+          assert_regexp(
+            "I have {n} cukes in my {bodypart} now",
+            /^I have (.+) cukes in my (.+) now$/
+          )
+        end
+
+        it "translates three typed arguments" do
+          assert_regexp(
+            "I have {n:float} cukes in my {bodypart} at {time:int} o'clock",
+            /^I have (-?\d*\.?\d+) cukes in my (.+) at (-?\d+) o'clock$/
+          )
+        end
+
+        it "translates parenthesis to non-capturing optional capture group" do
+          assert_regexp(
+            "I have many big(ish) cukes",
+            /^I have many big(?:ish)? cukes$/
+          )
+        end
+      end
+    end
+  end
+end

data/spec/cucumber/cucumber_expressions/cucumber_expression_spec.rb

@@ -0,0 +1,77 @@
+require 'cucumber/cucumber_expressions/cucumber_expression'
+require 'cucumber/cucumber_expressions/transform_lookup'
+
+module Cucumber
+  module CucumberExpressions
+    describe CucumberExpression do
+      it "documents match arguments" do
+        transform_lookup = TransformLookup.new
+
+        ### [capture-match-arguments]
+        expr = "I have {n} cuke(s) in my {bodypart} now"
+        types = ['int', nil]
+        expression = CucumberExpression.new(expr, types, transform_lookup)
+        args = expression.match("I have 7 cukes in my belly now")
+        expect( args[0].transformed_value ).to eq(7)
+        expect( args[1].transformed_value ).to eq("belly")
+        ### [capture-match-arguments]
+      end
+
+      it "transforms nothing by default" do
+        expect( match("{what}", "22") ).to eq(["22"])
+      end
+
+      it "transforms to int by expression type" do
+        expect( match("{what:int}", "22") ).to eq([22])
+      end
+
+      it "transforms to int by explicit type" do
+        expect( match("{what}", "22", ['int']) ).to eq([22])
+      end
+
+      # Ruby-specific
+      it "transforms to Fixnum by explicit type" do
+        expect( match("{what}", "22", [Fixnum]) ).to eq([22])
+      end
+
+      it "doesn't match a float to an int" do
+        expect( match("{what:int}", "1.22") ).to be_nil
+      end
+
+      it "transforms to float by expression type" do
+        expect( match("{what:float}", "0.22") ).to eq([0.22])
+        expect( match("{what:float}",  ".22") ).to eq([0.22])
+      end
+
+      it "transforms to float by explicit type" do
+        expect( match("{what}", "0.22", ['float']) ).to eq([0.22])
+        expect( match("{what}",  ".22", ['float']) ).to eq([0.22])
+      end
+
+      it "doesn't transform unknown type" do
+        expect { match("{what:unknown}", "something") }.to raise_error(
+          'No transform for type name "unknown"')
+      end
+
+      it "exposes source" do
+        expr = "I have {n:int} cuke(s) in my {bodypart} now"
+        expect(CucumberExpression.new(expr, [], TransformLookup.new).source).to eq(expr)
+      end
+
+      it "exposes offset and value" do
+        expr = "I have {n:int} cuke(s) in my {bodypart} now"
+        expression = CucumberExpression.new(expr, [], TransformLookup.new)
+        arg1 = expression.match("I have 800 cukes in my brain now")[0]
+        expect(arg1.offset).to eq(7)
+        expect(arg1.value).to eq("800")
+      end
+
+      def match(expression, text, types = [])
+        cucumber_expression = CucumberExpression.new(expression, types, TransformLookup.new)
+        args = cucumber_expression.match(text)
+        return nil if args.nil?
+        args.map { |arg| arg.transformed_value }
+      end
+    end
+  end
+end

data/spec/cucumber/cucumber_expressions/custom_transform_spec.rb

@@ -0,0 +1,81 @@
+require 'cucumber/cucumber_expressions/cucumber_expression'
+require 'cucumber/cucumber_expressions/regular_expression'
+require 'cucumber/cucumber_expressions/transform_lookup'
+
+module Cucumber
+  module CucumberExpressions
+    class Color
+      attr_reader :name
+
+      ### [color-constructor]
+      def initialize(name)
+        @name = name
+      end
+      ### [color-constructor]
+
+      def == (other)
+        other.is_a?(Color) && other.name == name
+      end
+    end
+
+    describe "Custom transform" do
+      before do
+        @transform_lookup = TransformLookup.new
+        ### [add-color-transform]
+        @transform_lookup.add_transform(Transform.new(
+          'color',
+          Color,
+          'red|blue|yellow',
+          lambda { |s| Color.new(s) }
+        ))
+        ### [add-color-transform]
+      end
+
+      describe CucumberExpression do
+        it "converts arguments with expression type" do
+          expression = CucumberExpression.new("I have a {color:color} ball", [], @transform_lookup)
+          transformed_argument_value = expression.match("I have a red ball")[0].transformed_value
+          expect( transformed_argument_value ).to eq(Color.new('red'))
+        end
+
+        it "converts arguments with explicit type" do
+          expression = CucumberExpression.new("I have a {color} ball", [Color], @transform_lookup)
+          transformed_argument_value = expression.match("I have a red ball")[0].transformed_value
+          expect( transformed_argument_value ).to eq(Color.new('red'))
+        end
+
+        it "converts arguments using argument name as type" do
+          expression = CucumberExpression.new("I have a {color} ball", [], @transform_lookup)
+          transformed_argument_value = expression.match("I have a red ball")[0].transformed_value
+          expect( transformed_argument_value ).to eq(Color.new('red'))
+        end
+
+        it "converts arguments with explicit type using constructor directly" do
+          expression = CucumberExpression.new("I have a {color} ball", [Color], TransformLookup.new)
+          transformed_argument_value = expression.match("I have a red ball")[0].transformed_value
+          expect( transformed_argument_value ).to eq(Color.new('red'))
+        end
+      end
+
+      describe RegularExpression do
+        it "converts arguments with expression type" do
+          expression = RegularExpression.new(/I have a (red|blue|yellow) ball/, [], @transform_lookup)
+          transformed_argument_value = expression.match("I have a red ball")[0].transformed_value
+          expect( transformed_argument_value ).to eq(Color.new('red'))
+        end
+
+        it "converts arguments with explicit type" do
+          expression = RegularExpression.new(/I have a (red|blue|yellow) ball/, ['color'], @transform_lookup)
+          transformed_argument_value = expression.match("I have a red ball")[0].transformed_value
+          expect( transformed_argument_value ).to eq(Color.new('red'))
+        end
+
+        it "converts arguments with explicit type using constructor directly" do
+          expression = RegularExpression.new(/I have a (red|blue|yellow) ball/, [Color], TransformLookup.new)
+          transformed_argument_value = expression.match("I have a red ball")[0].transformed_value
+          expect( transformed_argument_value ).to eq(Color.new('red'))
+        end
+      end
+    end
+  end
+end

data/spec/cucumber/cucumber_expressions/expression_examples_spec.rb

@@ -0,0 +1,30 @@
+require 'cucumber/cucumber_expressions/cucumber_expression'
+require 'cucumber/cucumber_expressions/regular_expression'
+require 'cucumber/cucumber_expressions/transform_lookup'
+require 'json'
+
+module Cucumber
+  module CucumberExpressions
+    describe 'examples.txt' do
+      def match(expression_text, text)
+        expression = expression_text =~ /\/(.*)\// ?
+          RegularExpression.new(Regexp.new($1), [], TransformLookup.new) :
+          CucumberExpression.new(expression_text, [], TransformLookup.new)
+
+        arguments = expression.match(text)
+        return nil if arguments.nil?
+        arguments.map { |arg| arg.transformed_value }
+      end
+
+      File.open(File.expand_path("../../../../examples.txt", __FILE__), "r:utf-8") do |io|
+        chunks = io.read.split(/^---/m)
+        chunks.each do |chunk|
+          expression_text, text, expected_args = *chunk.strip.split(/\n/m)
+          it "Works with: #{expression_text}" do
+            expect( match(expression_text, text).to_json ).to eq(expected_args)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/cucumber/cucumber_expressions/regular_expression_spec.rb

@@ -0,0 +1,70 @@
+require 'cucumber/cucumber_expressions/regular_expression'
+require 'cucumber/cucumber_expressions/transform_lookup'
+
+module Cucumber
+  module CucumberExpressions
+    describe RegularExpression do
+      it "documents match arguments" do
+        transform_lookup = TransformLookup.new
+
+        ### [capture-match-arguments]
+        expr = /I have (\d+) cukes? in my (\w*) now/
+        types = ['int', nil]
+        expression = RegularExpression.new(expr, types, transform_lookup)
+        args = expression.match("I have 7 cukes in my belly now")
+        expect( args[0].transformed_value ).to eq(7)
+        expect( args[1].transformed_value ).to eq("belly")
+        ### [capture-match-arguments]
+      end
+
+      it "transforms to string by default" do
+        expect( match(/(\d\d)/, "22") ).to eq(["22"])
+      end
+
+      it "transforms integer to double using explicit type name" do
+        expect( match(/(.*)/, "22", ['float']) ).to eq([22.0])
+      end
+
+      it "transforms integer to double using explicit type" do
+        expect( match(/(.*)/, "22", [Float]) ).to eq([22.0])
+      end
+
+      it "transforms to int using capture group pattern" do
+        expect( match(/(-?\d+)/, "22") ).to eq([22])
+      end
+
+      it "transforms to int by alternate capture group pattern" do
+        expect( match(/(\d+)/, "22") ).to eq([22])
+      end
+
+      it "transforms double without integer value" do
+        expect( match(/(.*)/, ".22", ['float']) ).to eq([0.22])
+      end
+
+      it "transforms double with sign" do
+        expect( match(/(.*)/, "-1.22", ['float']) ).to eq([-1.22])
+      end
+
+      it "returns nil when there is no match" do
+        expect( match(/hello/, "world") ).to be_nil
+      end
+
+      it "fails when type is not type name or class" do
+        expect( lambda { match(/(.*)/, "-1.22", [99]) } ).to raise_error(
+          'Type must be string or class, but was 99 of type Fixnum')
+      end
+
+      it "exposes source" do
+        expr = /I have (\d+) cukes? in my (\+) now/
+        expect(RegularExpression.new(expr, [], TransformLookup.new).source).to eq(expr)
+      end
+
+      def match(expression, text, types = [])
+        regular_expression = RegularExpression.new(expression, types, TransformLookup.new)
+        arguments = regular_expression.match(text)
+        return nil if arguments.nil?
+        arguments.map { |arg| arg.transformed_value }
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,147 @@
+--- !ruby/object:Gem::Specification
+name: cucumber-expressions
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Aslak Hellesøy
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-09-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.12.5
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.12.5
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 10.5.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 10.5.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.2
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+description: Cucumber Expressions - a simpler alternative to Regular Expressions
+email: cukes@googlegroups.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- Makefile
+- README.md
+- Rakefile
+- cucumber-expressions.gemspec
+- examples.txt
+- lib/cucumber/cucumber_expressions/argument.rb
+- lib/cucumber/cucumber_expressions/argument_matcher.rb
+- lib/cucumber/cucumber_expressions/cucumber_expression.rb
+- lib/cucumber/cucumber_expressions/cucumber_expression_generator.rb
+- lib/cucumber/cucumber_expressions/generated_expression.rb
+- lib/cucumber/cucumber_expressions/regular_expression.rb
+- lib/cucumber/cucumber_expressions/transform.rb
+- lib/cucumber/cucumber_expressions/transform_lookup.rb
+- lib/cucumber/cucumber_expressions/transform_matcher.rb
+- spec/capture_warnings.rb
+- spec/coverage.rb
+- spec/cucumber/cucumber_expressions/cucumber_expression_generator_spec.rb
+- spec/cucumber/cucumber_expressions/cucumber_expression_regexp_spec.rb
+- spec/cucumber/cucumber_expressions/cucumber_expression_spec.rb
+- spec/cucumber/cucumber_expressions/custom_transform_spec.rb
+- spec/cucumber/cucumber_expressions/expression_examples_spec.rb
+- spec/cucumber/cucumber_expressions/regular_expression_spec.rb
+homepage: https://cucumber.io/
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--charset=UTF-8"
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: cucumber-expressions-1.0.0
+test_files:
+- spec/capture_warnings.rb
+- spec/coverage.rb
+- spec/cucumber/cucumber_expressions/cucumber_expression_generator_spec.rb
+- spec/cucumber/cucumber_expressions/cucumber_expression_regexp_spec.rb
+- spec/cucumber/cucumber_expressions/cucumber_expression_spec.rb
+- spec/cucumber/cucumber_expressions/custom_transform_spec.rb
+- spec/cucumber/cucumber_expressions/expression_examples_spec.rb
+- spec/cucumber/cucumber_expressions/regular_expression_spec.rb