cuke-patterns 0.1.3 → 0.1.4

data/VERSION

@@ -1 +1 @@
-0.1.3
+0.1.4

data/cuke-patterns.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{cuke-patterns}
-  s.version = "0.1.3"
+  s.version = "0.1.4"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Brendan Baldwin"]
-  s.date = %q{2010-08-16}
+  s.date = %q{2010-08-18}
   s.description = %q{Makes cucumber step definitions more focused, understandable, searchable and awesomeable.}
   s.email = %q{brendan@usergenic.com}
   s.extra_rdoc_files = [
@@ -23,14 +23,17 @@ Gem::Specification.new do |s|
      "Rakefile",
      "VERSION",
      "cuke-patterns.gemspec",
-     "features/no_regressions_in_normal_cukes.feature",
-     "features/simple_cuke_patterns.feature",
-     "features/step_definitions/no_regression_steps.rb",
+     "features/apply_pattern.feature",
+     "features/apply_pattern_steps.rb",
+     "features/pattern_generator.feature",
+     "features/simple_patterns.feature",
+     "features/step_definitions/pattern_generator_steps.rb",
      "features/step_definitions/simple_pattern_steps.rb",
      "features/support/env.rb",
      "lib/cuke-patterns.rb",
      "lib/cuke-patterns/rb_dsl_ext.rb",
      "lib/cuke-patterns/rb_language_ext.rb",
+     "lib/cuke-patterns/rb_world_ext.rb",
      "lib/cuke-patterns/step_mother_ext.rb"
   ]
   s.homepage = %q{http://github.com/brendan/cuke-patterns}

data/features/apply_pattern.feature

@@ -0,0 +1,8 @@
+Feature: Apply Pattern
+
+Patterns can be called from within other Patterns.
+
+Scenario: A list pattern
+When @x contains 1, "potato", 2.0 and "potato"
+Then @x should be equal to [1, "potato", 2.0, "potato"]
+And @x should be an Array

data/features/apply_pattern_steps.rb

@@ -0,0 +1,9 @@
+When ":ivar_name contains :list" do |ivar, array|
+  instance_variable_set(ivar, array)
+end
+
+Pattern :list, /(.+(?:,| and ).+)/ do |list|
+  list.split(/ *(?:,|and) */).map do |item|
+    Pattern :value, item
+  end
+end

data/features/pattern_generator.feature

@@ -0,0 +1,13 @@
+Feature: Pattern Generator
+
+Sometimes its nice to be able to have a catch-all like Ruby's method_missing
+so we can do more dynamic things.  A PatternGenerator works like this, taking
+a string of word characters representing a "word" or ":symbol" and then
+returns a regexp and optional conversion proc.  If it returns neither, we
+move on to the next defined Pattern Generator.
+
+Scenario: singular/plural form agnosticizer
+When I eat 1 apple
+And I eat 2 apples
+Then I should have eaten 3 apples
+

data/features/simple_patterns.feature

@@ -0,0 +1,40 @@
+Feature: Simple Patterns
+These are some examples of very simple but useful patterns.
+
+Scenario: :fixnum
+When I assign @x to 1
+Then @x should be equal to 1
+And @x should be a Fixnum
+
+Scenario: :fixnum (negative)
+When I assign @x to -1
+Then @x should be equal to -1
+And @x should be a Fixnum
+
+Scenario: :float
+When I assign @x to 2.0
+Then @x should be equal to 2.0
+And @x should be a Float
+
+Scenario: :float (negative)
+When I assign @x to -2.0
+Then @x should be equal to -2.0
+And @x should be a Float
+
+Scenario: :hash
+When I assign @x to {'a'=>'b','c'=>'d'}
+Then @x should be equal to {'a'=>'b','c'=>'d'}
+And @x should be a Hash
+
+Scenario: :array
+When I assign @x to [1,2,3]
+Then @x should be equal to [1,2,3]
+And @x should be an Array
+
+Scenario: :string
+When I assign @x to "aww yeah"
+Then @x should be equal to "aww yeah"
+And @x should be a String
+
+
+

data/features/step_definitions/pattern_generator_steps.rb

@@ -0,0 +1,18 @@
+When "I eat :value apples" do |count|
+  @apples_consumed ||= 0
+  @apples_consumed += count
+end
+
+Then "I should have eaten :value apples" do |count|
+  @apples_consumed.should == count
+end
+
+# This pattern generator doesn't do *real* pluralize/singularize;
+# it's just a demonstration of the concept.  Here I strip and append
+# an 's' onto the word passed in and construct a regexp that looks
+# for all forms rather naively.
+PatternGenerator do |word|
+  base_plural_singular = [word, word+'s', word.sub(/s$/,'')].uniq
+  base_plural_singular.map! {|w| Regexp.escape(w)}
+  Regexp.new(base_plural_singular.join('|'))
+end

data/features/step_definitions/simple_pattern_steps.rb

@@ -1,39 +1,30 @@
-When "@x is :integer" do |integer|
-  @x = integer
+When "I assign :ivar_name to :value" do |ivar, value|
+  instance_variable_set(ivar, value)
 end
 
-When "@x contains :list_of_integers" do |list|
-  @x = list
+Then ":ivar should be equal to :value" do |ivar, value|
+  ivar.should == value
 end
 
-Then "@x should be a :class" do |klass|
-  @x.class.should == klass
+Then ":ivar should be a :class" do |ivar, klass|
+  ivar.should be_kind_of(klass)
 end
 
-Then /^@x should evaluate to (.*)$/ do |expression|
-  @x.should == eval(expression)
-end
+Pattern /a|an/
+Pattern /is|are/
 
-Pattern :class, /([A-Z][a-z]+)/ do |class_name|
-  Object.const_get(class_name)
+Pattern :class, /([A-Z]\w*(?:::[A-Z]\w*)*)/ do |class_name|
+  class_name.split(/::/).inject(Object) do |klass, subname|
+    klass.const_get(subname)
+  end
 end
 
-Pattern :integer, /(-?\d+)/ do |number|
-  number.to_i
+Pattern :ivar, /(@\w+)/ do |ivar_name|
+  instance_variable_get(ivar_name)
 end
 
-Pattern :list_of_integers, /(-?\d+(?: *(?:,|and) *-?\d+)*)/ do |list|
-  list.split(/ *(?:,|and) */).map{|number| number.to_i}
-end
+Pattern :ivar_name, /(@\w+)/
 
-PatternGenerator do |key|
-  %w[a an].include?(key) and /a|an/
+Pattern :value, /(.*)/ do |expression|
+  eval(expression)
 end
-
-## This PatternGenerator would enable automatic singularize/pluralize of ALL words
-## so you don't have to resort to regexp construction for steps just do deal with
-## pluralization related nonsense.
-#
-# PatternGenerator do |key|
-#   Regexp.new([Regexp.escape(key.singularize), Regexp.escape(key.pluralize)].join('|'))
-# end

data/lib/cuke-patterns.rb

@@ -3,5 +3,6 @@ end
 
 require 'cuke-patterns/rb_dsl_ext'
 require 'cuke-patterns/rb_language_ext'
+require 'cuke-patterns/rb_world_ext'
 require 'cuke-patterns/step_mother_ext'
 

data/lib/cuke-patterns/rb_dsl_ext.rb

@@ -1,8 +1,12 @@
 module CukePatterns
   module RbDslExt
 
-    def register_rb_cuke_pattern(name, regexp, &proc)
-      @rb_language.register_rb_cuke_pattern(name, regexp, &proc)
+    def apply_rb_cuke_pattern(name, string)
+      @rb_language.apply_rb_cuke_pattern(name, string)
+    end
+
+    def register_rb_cuke_pattern(*args, &proc)
+      @rb_language.register_rb_cuke_pattern(*args, &proc)
     end
 
     def register_rb_cuke_pattern_generator(&proc)
@@ -15,8 +19,8 @@ end
 Cucumber::RbSupport::RbDsl.module_eval do
   extend CukePatterns::RbDslExt
 
-  def Pattern(name, regexp, &proc)
-    Cucumber::RbSupport::RbDsl.register_rb_cuke_pattern(name, regexp, &proc)
+  def Pattern(*args, &proc)
+    Cucumber::RbSupport::RbDsl.register_rb_cuke_pattern(*args, &proc)
   end
 
   def PatternGenerator(&proc)

data/lib/cuke-patterns/rb_language_ext.rb

@@ -25,7 +25,7 @@ module CukePatterns
     end
 
     def cuke_patterns
-      @cuke_patterns ||= Hash.new {|hash, key| default_cuke_pattern(key)}
+      @cuke_patterns ||= {}
     end
 
     # Hook this method to automatically generate regexp matches for words in step
@@ -33,7 +33,7 @@ module CukePatterns
     def default_cuke_pattern(key)
       default_cuke_pattern_generators.each do |generator|
         regexp, proc = generator[key]
-        return [regexp, proc] if regexp
+        return regexp, proc if regexp
       end
       return nil
     end
@@ -42,8 +42,45 @@ module CukePatterns
       @default_cuke_pattern_generators ||= []
     end
 
-    def register_rb_cuke_pattern(name, regexp, &conversion_proc)
-      name = ":#{name}" if name.is_a?(Symbol) # so :user becomes ':user'
+    def apply_rb_cuke_pattern(name, string)
+      name = ":#{name}" if name.is_a?(Symbol)
+      regexp, proc = lookup_cuke_pattern(name)
+      match = regexp.match(string)
+      raise "Pattern #{regexp.to_s} does not match #{string.inspect}" unless match
+      return instance_exec(*match.captures, &proc) if proc
+      return match.to_s
+    end
+
+    def lookup_cuke_pattern(name)
+      keys, regexp, proc = [], nil, nil
+      cuke_patterns.each do |key, value|
+        if key === name
+          keys << key
+          regexp, proc = value
+        end
+      end
+      return default_cuke_pattern(name) if keys.empty?
+      return regexp, proc if keys.length == 1
+      raise "Ambiguous Pattern for #{name.inspect}: #{keys.inspect}"
+    end
+
+    def register_rb_cuke_pattern(*args, &conversion_proc)
+      if args.length == 1
+        if args.first.is_a?(Hash)
+          args.first.each do |key, value|
+            register_rb_cuke_pattern(key, value, &conversion_proc)
+          end
+          return
+        else
+          # We wrap the key form of the regexp in begin/end
+          # so that we match only whole tokens when doing lookup
+          name = Regexp.new("^(?:#{args.first})$")
+          regexp = args.first
+        end
+      elsif args.length == 2
+        name, regexp = args
+        name = ":#{name}" if name.is_a?(Symbol) # so :user becomes ':user'
+      end
 
       if conversion_proc
         # Count the capturing '(' characters to get the pattern arity
@@ -83,7 +120,7 @@ module CukePatterns
       # Split the string by non-alphanumeric, underscore or leading-colon characters
       matcher.scan(/(:?\w+)|([^:\w]+|:)/) do |candidate, non_candidate|
 
-        regexp, conversion_proc = cuke_patterns[candidate] if candidate
+        regexp, conversion_proc = lookup_cuke_pattern(candidate) if candidate
 
         if non_candidate or not regexp
           matcher_regexp << Regexp.escape(candidate || non_candidate)

data/lib/cuke-patterns/rb_world_ext.rb

@@ -0,0 +1,15 @@
+module CukePatterns
+
+  module RbWorldExt
+
+    def Pattern(name, string)
+      Cucumber::RbSupport::RbDsl.apply_rb_cuke_pattern(name, string)
+    end
+
+  end
+
+end
+
+Cucumber::RbSupport::RbWorld.module_eval do
+  include CukePatterns::RbWorldExt
+end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 1
-  - 3
-  version: 0.1.3
+  - 4
+  version: 0.1.4
 platform: ruby
 authors: 
 - Brendan Baldwin
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-16 00:00:00 -07:00
+date: 2010-08-18 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -34,14 +34,17 @@ files:
 - Rakefile
 - VERSION
 - cuke-patterns.gemspec
-- features/no_regressions_in_normal_cukes.feature
-- features/simple_cuke_patterns.feature
-- features/step_definitions/no_regression_steps.rb
+- features/apply_pattern.feature
+- features/apply_pattern_steps.rb
+- features/pattern_generator.feature
+- features/simple_patterns.feature
+- features/step_definitions/pattern_generator_steps.rb
 - features/step_definitions/simple_pattern_steps.rb
 - features/support/env.rb
 - lib/cuke-patterns.rb
 - lib/cuke-patterns/rb_dsl_ext.rb
 - lib/cuke-patterns/rb_language_ext.rb
+- lib/cuke-patterns/rb_world_ext.rb
 - lib/cuke-patterns/step_mother_ext.rb
 has_rdoc: true
 homepage: http://github.com/brendan/cuke-patterns

data/features/no_regressions_in_normal_cukes.feature

@@ -1,9 +0,0 @@
-Feature: No regressions in normal cukes
-  In order for anyone to want to use this cuke-patterns gem
-  As a developer of cuke-patterns
-  I want to ensure this doesn't screw anything up
-
-Scenario: Simple regexp matched scenario
-  Given a typical given step
-  When a typical when step
-  Then a typical then step

data/features/simple_cuke_patterns.feature

@@ -1,16 +0,0 @@
-Feature: Simple Cuke Patterns
-
-Scenario: Transform string of digits into Fixnum
-  When @x is 1234
-  Then @x should be a Fixnum
-  And @x should evaluate to 1234
-
-Scenario: Transform digits with negative sign into Fixnum
-  When @x is -1234
-  Then @x should be a Fixnum
-  And @x should evaluate to -1234
-
-Scenario: Transform a list to an array of Fixnums
-  When @x contains 1, 2, 3 and 4
-  Then @x should be an Array
-  And @x should evaluate to [1, 2, 3, 4]

data/features/step_definitions/no_regression_steps.rb

@@ -1,6 +0,0 @@
-Given /^a typical given step$/ do
-end
-When /^a typical when step$/ do
-end
-Then /^a typical then step$/ do
-end