form_input 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3bf25959262e5eb0029d1185a5c7a9901a43cd16
-  data.tar.gz: 678589bac2e0bdcf52ca76568d63ee18cde7e128
+  metadata.gz: d7eb22ab0a9fbdbf797fd70548c4caed7201b4e7
+  data.tar.gz: d8fd5dbc4f0e7a10238aedddb889c37163e419f6
 SHA512:
-  metadata.gz: f2d7d5d8caa65943d9765cf480f706614f7e77ad67766d5dddddb9f66f0f5f33c7d547aa614e648a5c43bf855c512d9764ea00988eafd3769ca5864733b7e281
-  data.tar.gz: fec7c3c8f5114861fefd20ed438a000bdab38f0c5bc912dd8a8a2d335e71c899b7ad22066b40598b1bf36ba3c1b0de1aeed87a5e8e528b4105655188db678f17
+  metadata.gz: 5d8ccd8693068596ca26d4d6b15ddfbd5434b558062de2371a154c1b5e562712792065ba4ec32bc937bcd4870cac1a4f4bab4e428409f02d75303d8707c9e9ad
+  data.tar.gz: 7df1a5feca9a80307e1f1fbeb6f5a1e840775743cf96136a45e723a7cd434117563b297d57264cb5169dab8534cc125ea5af3a0009a99cb6123d4e7ce4024946

data/CHANGELOG.md

@@ -0,0 +1,9 @@
+= 1.1.0
+
+ * Added report! methods for late reporting of the most fundamental errors.
+
+ * Added support for multiple `check` and `test` validation callbacks.
+
+= 1.0.0
+
+ * Initial release.

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2015-2016 Patrik Rak (patrik@raxoft.cz)
+Copyright (c) 2015-2018 Patrik Rak (patrik@raxoft.cz)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -171,7 +171,7 @@ The following two declarations are therefore the same:
 ```
 
 Parameters support many more parameter options,
-and we will discuss each in turn as we go.
+and we will discuss each one in turn as we go.
 Comprehensive summary for an avid reader is however available in [Parameter Options](#parameter-options).
 
 The value of each parameter is a string by default (or `nil` if the parameter is not set at all).
@@ -643,6 +643,10 @@ The advantage of the `:test` callback is that it works the same way regardless o
 scalar or not,
 so it is preferable to use it
 if you plan to factor this into a `COUNTRY_ARGS` helper which works with both kinds of parameters.
+If you do this,
+you should also know that each parameter can support multiple `:check` and `:test` callbacks,
+and when the parameter options are merged together, all of them are preserved by default
+(unless you set it to `nil`, which resets all previously defined ones).
 
 In either case, the `report` method is used to report any problems about the parameter,
 which marks the parameter as invalid at the same time.
@@ -951,14 +955,22 @@ and let them report any belated additional errors which might get detected durin
 for example:
 
 ``` ruby
-  form.report( :email, "Email is already taken" ) unless unique_email?( form.email )
+  form.report( :email, "Email address is already taken" ) unless unique_email?( form.email )
 ```
 
-As we have already seen, it is common to use the `report`
+If you want the error message to have priority over anything else what might have been reported before,
+you can use the `report!` method instead:
+
+``` ruby
+  form.filled_params.each{ |p| p.report!( "Fill only one of these" ) } unless form.filled_params.one?
+```
+
+As we have already seen [before](#array-and-hash-parameters), it is common to use the `report`
 method from within the `:check` or `:test` callback of the parameter itself as well:
 
 ``` ruby
-  check: ->{ report( "%p is already taken" ) unless unique_email?( value ) }
+  check: ->{ report( "%p is odd number" ) unless value.to_i.even? }
+  test: ->( value ){ report( "%p contain odd number" ) unless value.to_i.even? }
 ```
 
 In this case the `%p` string is replaced by the `title` of the parameter.
@@ -1119,13 +1131,17 @@ so you can get back to it using the `form` method if you need to:
   fail unless p.form.valid?
 ```
 
-As we have seen, you can report errors about the parameter using its `report` method.
+As we have seen, you can report errors about the parameter using its `report` or `report!` methods.
 You can ask it about all its errors or just the first error using the `errors` or `error` methods, respectively:
 
 ``` ruby
   p.report( "This is invalid" )
   p.errors        # [ "This is invalid" ]
   p.error         # "This is invalid"
+
+  p.report!( "Do not fill this!" )
+  p.errors        # [ "Do not fill this!", "This is invalid" ]
+  p.error         # "Do not fill this!"
 ```
 
 You can also simply ask whether the parameter is valid or not by using the `valid?` and `invalid?` methods.
@@ -1398,7 +1414,7 @@ you will eventually want to extend it further to better fit your project.
 To do this, it's common to define the `Form` class inherited from `FormInput`,
 put various helpers there, and base your own forms on that.
 This is also the place where you can include your own `FormInput` types extensions.
-This chapter shows some ideas you may want to built upon to get you started.
+This chapter shows some ideas you may want to build upon to get you started.
 
 Adding custom boolean getters which you may need:
 
@@ -1488,9 +1504,9 @@ This is a brief but comprehensive summary of all parameter options:
   See [Output Format](#output-format).
 * `:class` - object type (or array thereof) which the input filter is expected to convert the input value into.
   See [Input Filter](#input-filter).
-* `:check` - optional callback used to perform arbitrary checks when testing the parameter validity.
+* `:check` - optional callback (or array thereof) used to perform arbitrary checks when testing the parameter validity.
   See [Errors and Validation](#errors-and-validation).
-* `:test` - optional callback used to perform arbitrary tests when testing validity of each parameter value.
+* `:test` - optional callback (or array thereof) used to perform arbitrary tests when testing validity of each parameter value.
   See [Errors and Validation](#errors-and-validation).
 * `:min_key` - minimum allowed value for keys of hash parameters. Defaults to 0.
 * `:max_key` - maximum allowed value for keys of hash parameters. Defaults to 2<sup>64</sup>-1.
@@ -1554,8 +1570,7 @@ For example, this is a `snippet` helper based on [Sinatra]'s partials:
 
 ``` ruby
   # Render partial, our style.
-  def snippet( name, opts = {}, locals = nil )
-    opts, locals = {}, opts unless locals
+  def snippet( name, opts = {}, **locals )
     partial( "snippets/#{name}", opts.merge( locals: locals ) )
   end
 ```
@@ -2683,7 +2698,7 @@ you can override it by setting the `:plural` parameter option to `true` or `'p'`
 and to `false` or `'s'` for singular, respectively:
 
 ``` ruby
-  param :keywords, "Keywords, plural: true
+  param :keywords, "Keywords", plural: true
   array :countries, "List of countries", plural: false
 ```
 
@@ -2959,7 +2974,7 @@ might look like:
 
 The `pt` method is usable only in the parameter context.
 It works similar to the `ft` method,
-except that all translations are automatically looked up in the parameter's own ``forms.<form_translation_name>.<parameter_name>` namespace,
+except that all translations are automatically looked up in the parameter's own `forms.<form_translation_name>.<parameter_name>` namespace,
 rather than the global namespace.
 
 ``` ruby

data/form_input.gemspec

@@ -21,7 +21,7 @@ EOT
   s.homepage    = 'https://github.com/raxoft/form_input'
   s.license     = 'MIT'
 
-  s.files       = %w[ LICENSE README.md Rakefile .yardopts form_input.gemspec ] + Dir[ '{lib,test,example}/**/*.{rb,yml,txt,slim}' ]
+  s.files       = %w[ LICENSE README.md CHANGELOG.md Rakefile .yardopts form_input.gemspec ] + Dir[ '{lib,test,example}/**/*.{rb,yml,txt,slim}' ]
 
   s.required_ruby_version = '>= 2.0.0'
   s.add_runtime_dependency 'rack', '>= 1.5', '< 3.0'

data/lib/form_input/core.rb

@@ -49,6 +49,9 @@ class FormInput
     match_msg: "%p like this is not valid",
   }
 
+  # Parameter options which can be merged together into an array when multiple option hashes are merged.
+  MERGEABLE_OPTIONS = [ :check, :test ]
+
   # Form parameter.
   class Parameter
 
@@ -336,12 +339,22 @@ class FormInput
 
       # Report an error concerning this parameter.
       # String %p in the message is automatically replaced with error title.
+      # In case of multiple errors, the message is added to the end of the list, making it less important than the other errors.
       # Returns self for chaining.
       def report( msg, *args )
         form.report( name, format_error_message( msg, *args ) ) if form
         self
       end
 
+      # Report an error concerning this parameter.
+      # String %p in the message is automatically replaced with error title.
+      # In case of multiple errors, the message is added to the beginning of the list, making it more important than the other errors.
+      # Returns self for chaining.
+      def report!( msg, *args )
+        form.report!( name, format_error_message( msg, *args ) ) if form
+        self
+      end
+
     end
 
     include LocaleMethods
@@ -373,10 +386,10 @@ class FormInput
         validate_value( value )
       end
 
-      # Finally, invoke the custom check callback if there is any.
+      # Finally, invoke the custom check callbacks if there are any.
 
-      if check = opts[ :check ]
-        instance_exec( &check )
+      if checks = opts[ :check ]
+        [ *checks ].each{ |x| instance_exec( &x ) }
       end
     end
 
@@ -512,10 +525,10 @@ class FormInput
         return
       end
 
-      # Finally, invoke the custom callback if there is any.
+      # Finally, invoke the custom callbacks if there are any.
 
-      if test = opts[ :test ]
-        instance_exec( value, &test )
+      if tests = opts[ :test ]
+        [ *tests ].each{ |x| instance_exec( value, &x ) }
         return unless valid?
       end
 
@@ -662,7 +675,7 @@ class FormInput
       size = args.shift if args.first.is_a? Numeric
 
       opts = {}
-      opts.merge!( args.shift ) while args.first.is_a? Hash
+      opts.merge!( args.shift ){ |k, o, n| ( n && MERGEABLE_OPTIONS.include?( k ) ) ? [ *o, *n ] : n } while args.first.is_a? Hash
 
       fail ArgumentError, "invalid arguments #{args}" unless args.empty?
 
@@ -1099,6 +1112,7 @@ class FormInput
   end
 
   # Remember error concerning given parameter.
+  # In case of multiple errors, the message is added to the end of the list, making it less important than the other errors.
   # Returns self for chaining.
   def report( name, msg )
     validate?
@@ -1106,6 +1120,15 @@ class FormInput
     self
   end
 
+  # Remember error concerning given parameter.
+  # In case of multiple errors, the message is added to the beginning of the list, making it more important than the other errors.
+  # Returns self for chaining.
+  def report!( name, msg )
+    validate?
+    ( @errors[ name ] ||= [] ).unshift( msg.to_s.dup.freeze )
+    self
+  end
+
   # Get list of errors for given parameter. Returns empty list if there were no errors.
   def errors_for( name )
     errors[ name ] || []

data/lib/form_input/steps.rb

@@ -338,22 +338,22 @@ class FormInput
       finished_step?( step ) and incorrect_step?( step )
     end
 
-    # Get steps which shell be displayed as correct.
+    # Get steps which shall be displayed as correct.
     def good_steps
       steps.select{ |step| good_step?( step ) }
     end
 
-    # Get steps which shell be displayed as incorrect.
+    # Get steps which shall be displayed as incorrect.
     def bad_steps
       steps.select{ |step| bad_step?( step ) }
     end
 
-    # Test if given/current step shell be displayed as correct.
+    # Test if given/current step shall be displayed as correct.
     def good_step?( step = self.step )
       complete_step?( step ) and filled_step?( step ) and regular_step?( step )
     end
 
-    # Test if given/current step shell be displayed as incorrect.
+    # Test if given/current step shall be displayed as incorrect.
     def bad_step?( step = self.step )
       incomplete_step?( step )
     end

data/lib/form_input/version.rb

@@ -3,7 +3,7 @@
 class FormInput
   module Version
     MAJOR = 1
-    MINOR = 0
+    MINOR = 1
     PATCH = 0
     STRING = [ MAJOR, MINOR, PATCH ].join( '.' ).freeze
   end

data/test/helper.rb

@@ -6,16 +6,15 @@ def jruby?
   defined?( RUBY_ENGINE ) and RUBY_ENGINE == 'jruby'
 end
 
-if ENV[ 'COVERAGE' ]
-  require 'simplecov'
-  SimpleCov.start
-end
-
 begin
   require 'codeclimate-test-reporter'
-  CodeClimate::TestReporter.start
   ENV[ 'COVERAGE' ] = 'on'
 rescue LoadError
 end unless jruby?
 
+if ENV[ 'COVERAGE' ]
+  require 'simplecov'
+  SimpleCov.start
+end
+
 # EOF #

data/test/test_core.rb

@@ -380,6 +380,55 @@ describe FormInput do
     f.error_messages.should == [ "s may have at most 5 characters" ]
   end
 
+  should 'support reasonable option merging' do
+    c = Class.new( FormInput )
+    c.param :p, { max_size: 2 }, { min_size: 2, max_size: 3 }, { max_size: 4 }
+    c[ :p ][ :min_size ].should == 2
+    c[ :p ][ :max_size ].should == 4
+
+    c = Class.new( FormInput )
+    c.param :p, { tag: :foo }, { tag: :bar }, { tags: [ :x, :y ] }
+    c.param :q, { tag: :foo }, { tag: :bar }, { tag: nil }, { tags: [ :x, :y ] }
+    c.param :r, { tag: :foo }, { tag: :bar }, { tags: [ :x, :y ] }, { tags: nil }
+    c[ :p ].tags.should == [ :bar, :x, :y ]
+    c[ :q ].tags.should == [ :x, :y ]
+    c[ :r ].tags.should == [ :bar ]
+
+    c = Class.new( FormInput )
+    c.param :p, { tags: :foo }, { tags: :bar }, { tags: [ :x, :y ] }
+    c.param :q, { tags: :foo }, { tags: :bar }, { tags: nil }, { tags: [ :x, :y ] }
+    c.param :r, { tags: :foo }, { tags: :bar }, { tags: [ :x, :y ] }, { tags: nil }
+    c[ :p ].tags.should == [ :x, :y ]
+    c[ :q ].tags.should == [ :x, :y ]
+    c[ :r ].tags.should == []
+
+    c = Class.new( FormInput )
+    c.param :p, { check: ->{ report( "A" ) } }, { check: ->{ report( "B" ) } }
+    c.param :q, { check: ->{ report( "A" ) } }, { check: nil }, { check: ->{ report( "B" ) } }
+    c.param :r, { check: ->{ report( "A" ) } }, { check: ->{ report( "B" ) } }, { check: nil }
+    c.new( p: "x" ).errors_for( :p ).should == [ "A", "B" ]
+    c.new( q: "x" ).errors_for( :q ).should == [ "B" ]
+    c.new( r: "x" ).errors_for( :q ).should == []
+
+    c = Class.new( FormInput )
+    c.param :p, { test: ->( value ){ report( "A" ) } }, { test: ->( value ){ report( "B" ) } }
+    c.param :q, { test: ->( value ){ report( "A" ) } }, { test: nil }, { test: ->( value ){ report( "B" ) } }
+    c.param :r, { test: ->( value ){ report( "A" ) } }, { test: ->( value ){ report( "B" ) } }, { test: nil }
+    c.new( p: "x" ).errors_for( :p ).should == [ "A", "B" ]
+    c.new( q: "x" ).errors_for( :q ).should == [ "B" ]
+    c.new( r: "x" ).errors_for( :q ).should == []
+
+    for name in [:reject, :match, :match_key]
+      c = Class.new( FormInput )
+      c.param :p, { name => /\d/ }, { name => /[A-Z]/ }
+      c.param :q, { name => /\d/ }, { name => nil }, { name => /[A-Z]/ }
+      c.param :r, { name => /\d/ }, { name => /[A-Z]/ }, { name => nil }
+      c[ :p ][ name ].should == /[A-Z]/
+      c[ :q ][ name ].should == /[A-Z]/
+      c[ :r ][ name ].should == nil
+    end
+  end
+
   should 'convert to/from internal value format' do
     c = Class.new( FormInput )
     c.param :str
@@ -1224,6 +1273,19 @@ describe FormInput do
     f[].errors_for( :password ).should == [ "bad" ]
     f[].error_for( :password ).should == "bad"
 
+    f = TestForm.new.report!( :query, "important" ).report( :query, "less important" )
+    f.errors.should == { query: [ "important", "q is required", "less important" ] }
+    f.error_messages.should == [ "important" ]
+    f.errors_for( :query ).should == [ "important", "q is required", "less important" ]
+    f.error_for( :query ).should == "important"
+
+    f = TestForm.new
+    f.param( :query ).report( "less important" ).report!( "important" )
+    f.errors.should == { query: [ "important", "q is required", "less important" ] }
+    f.error_messages.should == [ "important" ]
+    f.errors_for( :query ).should == [ "important", "q is required", "less important" ]
+    f.error_for( :query ).should == "important"
+
     f = TestForm.new
     f.should.be.invalid
     f.set( query: "x" ).should.be.valid

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: form_input
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Patrik Rak
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-08-03 00:00:00.000000000 Z
+date: 2018-03-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -86,6 +86,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".yardopts"
+- CHANGELOG.md
 - LICENSE
 - README.md
 - Rakefile