formeze 1.3.0 → 1.4.0

data/README.md

@@ -150,6 +150,22 @@ end
 In this example, the `billing_address_line_one` field will only be defined
 and validated if the `same_address` checkbox is checked.
 
+Validation errors can be a frustrating experience for end users, so ideally
+we want to [be liberal in what we accept](http://en.wikipedia.org/wiki/Jon_Postel#Postel.27s_Law),
+but at the same time ensuring that data is consistently formatted to make it
+easy for us to process. Meet the `scrub` option, which can be used to specify
+methods for "cleaning" input data before validation. For example:
+
+```ruby
+field :postcode, scrub: [:strip, :squeeze, :upcase]
+```
+
+The input for this field will have leading/trailing whitespace stripped,
+double (or more) spaces squeezed, and the result upcased automatically.
+
+In order to define a custom scrub method just add a symbol/proc entry to
+the `Formeze.scrub_methods` hash.
+
 
 Rails usage
 -----------

data/formeze.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = 'formeze'
-  s.version = '1.3.0'
+  s.version = '1.4.0'
   s.platform = Gem::Platform::RUBY
   s.authors = ['Tim Craft']
   s.email = ['mail@timcraft.com']

data/lib/formeze.rb

@@ -18,19 +18,23 @@ module Formeze
       @name, @options = name, options
     end
 
-    def validate(value, &block)
-      if value !~ /\S/ # blank
-        block.call(error(:required, 'is required')) if required?
-      else
-        block.call(error(:not_multiline, 'cannot contain newlines')) if !multiline? && value.lines.count > 1
+    def scrub(value)
+      Array(@options[:scrub]).inject(value) do |tmp, scrub_method|
+        Formeze.scrub_methods.fetch(scrub_method).call(tmp)
+      end
+    end
 
-        block.call(error(:too_long, 'is too long')) if value.chars.count > char_limit
+    def validate(value)
+      if blank?(value)
+        yield error(:required, 'is required') if required?
+      else
+        yield error(:not_multiline, 'cannot contain newlines') if !multiline? && value.lines.count > 1
 
-        block.call(error(:too_long, 'is too long')) if word_limit? && value.scan(/\w+/).length > word_limit
+        yield error(:too_long, 'is too long') if too_long?(value)
 
-        block.call(error(:no_match, 'is invalid')) if pattern? && value !~ pattern
+        yield error(:no_match, 'is invalid') if no_match?(value)
 
-        block.call(error(:bad_value, 'is invalid')) if values? && !values.include?(value)
+        yield error(:bad_value, 'is invalid') if values? && !values.include?(value)
       end
     end
 
@@ -47,11 +51,7 @@ module Formeze
     end
 
     def label
-      if @options.has_key?(:label)
-        @options[:label]
-      else
-        translate(name, scope: [:formeze, :labels], default: Label.new(name))
-      end
+      @options.fetch(:label) { translate(name, scope: [:formeze, :labels], default: Label.new(name)) }
     end
 
     def required?
@@ -66,24 +66,24 @@ module Formeze
       @options.fetch(:multiple) { false }
     end
 
-    def char_limit
-      @options.fetch(:char_limit) { 64 }
+    def too_long?(value)
+      too_many_characters?(value) || too_many_words?(value)
     end
 
-    def word_limit?
-      @options.has_key?(:word_limit)
+    def too_many_characters?(value)
+      value.chars.count > @options.fetch(:char_limit) { 64 }
     end
 
-    def word_limit
-      @options.fetch(:word_limit)
+    def too_many_words?(value)
+      @options.has_key?(:word_limit) && value.scan(/\w+/).length > @options[:word_limit]
     end
 
-    def pattern?
-      @options.has_key?(:pattern)
+    def no_match?(value)
+      @options.has_key?(:pattern) && value !~ @options[:pattern]
     end
 
-    def pattern
-      @options.fetch(:pattern)
+    def blank?(value)
+      value !~ /\S/
     end
 
     def values?
@@ -218,11 +218,13 @@ module Formeze
         end
 
         values.each do |value|
-          field.validate(value) do |error|
+          scrubbed_value = field.scrub(value)
+
+          field.validate(scrubbed_value) do |error|
             errors << UserError.new("#{field.label} #{error}")
           end
 
-          send(:"#{field.name}=", value)
+          send(:"#{field.name}=", scrubbed_value)
         end
       end
 
@@ -252,6 +254,16 @@ module Formeze
     end
   end
 
+  def self.scrub_methods
+    @scrub_methods ||= {
+      :strip => :strip.to_proc,
+      :upcase => :upcase.to_proc,
+      :downcase => :downcase.to_proc,
+      :squeeze => proc { |string| string.squeeze(' ') },
+      :squeeze_lines => proc { |string| string.gsub(/(\r?\n)(\r?\n)(\r?\n)+/, '\\1\\2') }
+    }
+  end
+
   def self.setup(form)
     form.send :include, InstanceMethods
 

data/spec/formeze_spec.rb

@@ -507,3 +507,22 @@ describe 'I18n integration' do
     form.errors.first.to_s.must_equal('TITLE is required')
   end
 end
+
+class FormWithScrubbedFields
+  Formeze.setup(self)
+
+  field :postcode, scrub: [:strip, :squeeze, :upcase], pattern: /\A[A-Z0-9]{2,4} [A-Z0-9]{3}\z/
+  field :bio, scrub: [:strip, :squeeze_lines], multiline: true
+end
+
+describe 'FormWithScrubbedFields' do
+  describe 'parse method' do
+    it 'should apply the scrub methods to the input before validation' do
+      form = FormWithScrubbedFields.new
+      form.parse('postcode=++sw1a+++1aa&bio=My+name+is+Cookie+Monster.%0A%0A%0A%0AI+LOVE+COOKIES!!!!%0A%0A%0A%0A')
+      form.postcode.must_equal('SW1A 1AA')
+      form.bio.count(?\n).must_equal(2)
+      form.valid?.must_equal(true)
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: formeze
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.4.0
   prerelease: 
 platform: ruby
 authors: