turnip 2.0.2 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 97ce8b4d21720145507381ad113a78d36bb552a0
-  data.tar.gz: 8dae7e25fb5fe1dd0d4fff49ed42de48da147c3c
+  metadata.gz: 7d33fc5658dab981447e096b6da7db0efeed9fae
+  data.tar.gz: a83b232810d235ec830fdcade9327e339c7dc104
 SHA512:
-  metadata.gz: 8b02c8f565a8b495e5e244f12ed6994df4897e6e6b343edb53dd46590a324adfbc5a099c53109caf7597524259f66d303bd5fd3af437f404ad39cc843b39bfef
-  data.tar.gz: bd50fdde50f4f1de7ae33843ac93f9e9fcc275bebba93f6bc6b60d8bb10f74f2b818ff2b268ceec9994339598d3564633468e192c705d5125a530a6d57c2a288
+  metadata.gz: c4081ba73a394b32bd771c894203c9dad8211d29ddc20988f000a55ff20cff2c2a556ea2a280106988216b3aaf903b8c9d781194ee8b72172481326db630709b
+  data.tar.gz: c3ccbe7bb743449eee4b75fa79502bcfe28dab9b06600b479646760cd669b6582d30d4a0022251d5a276842375045fb74f00ad231d4652abc64b9809572805af

data/.travis.yml

@@ -6,7 +6,6 @@ cache: bundler
 branches:
   only:
     - master
-    - 2_0_0_rc1
 
 matrix:
   allow_failures:
@@ -15,9 +14,9 @@ matrix:
     - rvm: ruby-head
 
 rvm:
-  - 2.0.0
   - 2.1
   - 2.2
+  - 2.3.0
   - ruby-head
   - jruby-19mode
 

data/README.md

@@ -48,8 +48,8 @@ Please create a topic branch for every separate change you make.
 
 ### 1. Ruby
 
-- Support Ruby 2.x
-- Does not support Ruby 1.9.X
+- Support Ruby 2.1 or higher
+- Does not support Ruby 1.9.X and 2.0.X
 - Does not work on Ruby 1.8.X
 
 ### 2. RSpec
@@ -392,6 +392,16 @@ Then I should see 'Danger! Monsters ahead!'
  And I should not see 'Game over!'
 ```
 
+You can also define custom placeholder without specific regexp, that matches the same value of the default placeholder like this:
+
+```ruby
+placeholder :monster_name do
+  default do |name|
+    Monster.find_by!(name: name)
+  end
+end
+```
+
 ## Table Steps
 
 Turnip also supports steps that take a table as a parameter similar to Cucumber:

data/examples/steps/steps.rb

@@ -65,14 +65,14 @@ step "the monster should be dead" do
 end
 
 step "there are the following monsters:" do |table|
-  @monsters = {}
+  $monsters = {}
   table.hashes.each do |hash|
-    @monsters[hash['Name']] = hash['Hitpoints'].to_i
+    $monsters[hash['Name']] = hash['Hitpoints'].to_i
   end
 end
 
-step ":name should have :count hitpoints" do |name, count|
-  @monsters[name].should eq(count.to_i)
+step ":monster should have :count hitpoints" do |monster, count|
+  monster.should eq(count.to_i)
 end
 
 step "the monster sings the following song" do |song|
@@ -118,3 +118,9 @@ placeholder :color do
     color.to_sym
   end
 end
+
+placeholder :monster do
+  default do |name|
+    $monsters[name]
+  end
+end

data/lib/turnip/placeholder.rb

@@ -27,8 +27,8 @@ module Turnip
 
       def default
         @default ||= new(:default) do
-          match %r((?:"([^"]*)"|'([^']*)'|([[:alnum:]_-]+))) do |first, second, third|
-            first or second or third
+          default do |value|
+            value
           end
         end
       end
@@ -37,6 +37,7 @@ module Turnip
     def initialize(name, &block)
       @name = name
       @matches = []
+      @default = nil
       instance_eval(&block)
     end
 
@@ -49,18 +50,31 @@ module Turnip
       @matches << Match.new(regexp, block)
     end
 
+    def default(&block)
+      @default ||= Match.new(
+        %r{['"]?((?:(?<=")[^"]*)(?=")|(?:(?<=')[^']*(?='))|(?<!['"])[[:alnum:]_-]+(?!['"]))['"]?},
+        block
+      )
+    end
+
     def regexp
-      Regexp.new(@matches.map(&:regexp).join('|'))
+      Regexp.new(placeholder_matches.map(&:regexp).join('|'))
     end
 
   private
 
     def find_match(value)
-      @matches.each do |m|
+      placeholder_matches.each do |m|
         result = value.scan(m.regexp)
         return m, result.flatten unless result.empty?
       end
       nil
     end
+
+    def placeholder_matches
+      matches = @matches
+      matches += [@default] if @default
+      matches
+    end
   end
 end

data/lib/turnip/version.rb

@@ -1,3 +1,3 @@
 module Turnip
-  VERSION = '2.0.2'
+  VERSION = '2.1.0'
 end

data/spec/placeholder_spec.rb

@@ -1,67 +1,138 @@
 require 'turnip/placeholder'
 
 describe Turnip::Placeholder do
-  def anchor(exp)
-    Regexp.new("^#{exp}$")
-  end
+  describe '.resolve' do
+    before do
+      described_class.add(:test) do
+        match(/foo/)
+        match(/\d/)
+      end
+    end
 
-  describe ".resolve" do
-    it "returns a regexp for the given placeholder" do
-      placeholder = Turnip::Placeholder.add(:test) { match(/foo/); match(/\d/) }
-      resolved = Turnip::Placeholder.resolve(:test)
-      "foo".should =~ anchor(resolved)
-      "5".should =~ anchor(resolved)
-      "bar".should_not =~ anchor(resolved)
+    it 'returns a regexp for the given placeholder' do
+      resolved = described_class.resolve(:test)
+
+      expect('foo').to match(resolved)
+      expect('bar').not_to match(resolved)
+      expect('5').to match(resolved)
     end
 
-    it "fall through to using the standard placeholder regexp" do
-      resolved = Turnip::Placeholder.resolve(:does_not_exist)
-      "foo".should =~ anchor(resolved)
-      '"this is a test"'.should =~ anchor(resolved)
-      "foo bar".should_not =~ anchor(resolved)
+    it 'fall through to using the standard placeholder regexp' do
+      resolved = described_class.resolve(:does_not_exist)
+
+      match_standard_regexp_strings = [
+        [ %q(non_space_string),      'non_space_string'    ],
+        [ %q('around single quote'), 'around single quote' ],
+        [ %q("around double quote"), 'around double quote' ],
+      ]
+
+      match_standard_regexp_strings.each do |step, expect_str|
+        actual_str = resolved.match(step).captures.find { |m| !m.nil? }
+        expect(expect_str).to eq(actual_str)
+      end
+
+      mismatch_standard_regexp_strings = [
+        [ %q(with space string),  'with space string' ],
+        [ %q('single to double"), 'single to double'  ],
+        [ %q("double to single'), 'double to single'  ],
+        [ %q("double to none),    'double to none'  ],
+        [ %q(none to single'),    'none to single'  ],
+      ]
+
+      mismatch_standard_regexp_strings.each do |step, expect_str|
+        actual_str = resolved.match(step).captures.find { |m| !m.nil? }
+        expect(expect_str).not_to eq(actual_str)
+      end
     end
   end
 
-  describe ".apply" do
-    it "returns a regexp for the given placeholder" do
-      placeholder = Turnip::Placeholder.add(:test) do
+  describe '.apply' do
+    it 'recognize multiple placeholders and return block value' do
+      described_class.add :test1 do
         match(/foo/) { :foo_bar }
         match(/\d/) { |num| num.to_i }
       end
-      Turnip::Placeholder.apply(:test, "foo").should eq(:foo_bar)
-      Turnip::Placeholder.apply(:test, "5").should eq(5)
-      Turnip::Placeholder.apply(:test, "bar").should eq("bar")
-    end
 
-    it "extracts any captured expressions and passes them to the block" do
-      placeholder = Turnip::Placeholder.add(:test) do
-        match(/mo(nk)(ey)/) { |nk, ey| nk.to_s.reverse + '|' + ey.to_s.upcase }
+      described_class.add :test2 do
+        match(/bar/) { :bar_foo }
+        match(/\d/) { |num| num.to_i * 2 }
       end
-      Turnip::Placeholder.apply(:test, "monkey").should eq('kn|EY')
-      Turnip::Placeholder.apply(:test, "bar").should eq("bar")
+
+      expect(described_class.apply(:test1, 'foo')).to eq(:foo_bar)
+      expect(described_class.apply(:test1, 'bar')).to eq('bar')
+      expect(described_class.apply(:test1, '5')).to eq(5)
+
+      expect(described_class.apply(:test2, 'foo')).to eq('foo')
+      expect(described_class.apply(:test2, 'bar')).to eq(:bar_foo)
+      expect(described_class.apply(:test2, '5')).to eq(10)
     end
   end
 
-  describe "#regexp" do
-    it "should match a given fragment" do
-      placeholder = Turnip::Placeholder.new(:test) { match(/foo/) }
-      "foo".should =~ placeholder.regexp
+  describe '#apply' do
+    it 'extracts a captured expression and passes to the block' do
+      placeholder = described_class.new(:test) do
+        default { |value| value.gsub(' ', '').to_sym }
+        match(/foo/) { :foo_bar }
+        match(/\d/) { |num| num.to_i }
+
+        # It will be ignored (does not override first `default`)
+        default { |value| value.gsub(' ', '-').to_sym }
+      end
+
+      expect(placeholder.apply('foo')).to eq :foo_bar
+      expect(placeholder.apply('bar')).to eq :bar
+      expect(placeholder.apply('"fizz buzz"')).to eq :fizzbuzz
+      expect(placeholder.apply("'fizz buzz'")).to eq :fizzbuzz
+      expect(placeholder.apply('5')).to eq 5
     end
 
-    it "should match multiple fragments" do
-      placeholder = Turnip::Placeholder.new(:test) { match(/foo/); match(/\d/) }
-      "foo".should =~ placeholder.regexp
-      "5".should =~ placeholder.regexp
+    it 'extracts any captured expressions and passes to the block' do
+      placeholder = described_class.new(:test) do
+        match(/mo(nk)(ey)/) { |nk, ey| nk.to_s.reverse + '|' + ey.to_s.upcase }
+      end
+
+      expect(placeholder.apply('monkey')).to eq('kn|EY')
+      expect(placeholder.apply('bar')).to eq('bar')
     end
+  end
+
+  describe '#regexp' do
+    context 'placeholder has a matcher' do
+      let :placeholder do
+        described_class.new(:test) do
+          match(/foo/)
+        end
+      end
 
-    it "should not match an incorrect fragment" do
-      placeholder = Turnip::Placeholder.new(:test) { match(/foo/) }
-      "bar".should_not =~ placeholder.regexp
+      it 'should match a given fragment' do
+        expect('foo').to match(placeholder.regexp)
+        expect('the fool').to match(placeholder.regexp)
+      end
+
+      it 'should not match an incorrect fragment' do
+        expect('bar').not_to match(placeholder.regexp)
+      end
     end
 
-    it "should not multiple incorrect fragments" do
-      placeholder = Turnip::Placeholder.new(:test) { match(/foo/); match(/\d/) }
-      "bar".should_not =~ placeholder.regexp
+    context 'placeholder has multiple matchers' do
+      let :placeholder do
+        described_class.new(:test) do
+          match(/foo/)
+          match(/\d/)
+        end
+      end
+
+      it 'should match multiple fragments' do
+        expect('foo').to match(placeholder.regexp)
+        expect('5').to match(placeholder.regexp)
+
+        expect('the fool').to match(placeholder.regexp)
+        expect('12345678').to match(placeholder.regexp)
+      end
+
+      it 'should not multiple incorrect fragments' do
+        expect('bar').not_to match(placeholder.regexp)
+      end
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: turnip
 version: !ruby/object:Gem::Version
-  version: 2.0.2
+  version: 2.1.0
 platform: ruby
 authors:
 - Jonas Nicklas
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-13 00:00:00.000000000 Z
+date: 2016-03-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec