validatious-on-rails 0.3.1

data/lib/validatious-on-rails/validatious/client_side_validator.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+require File.join(File.dirname(__FILE__), 'validator')
+
+module ValidatiousOnRails
+  module Validatious
+    class ClientSideValidator < Validator
+      
+      def initialize(name, *args)
+        super
+      end
+      
+    end
+  end
+end

data/lib/validatious-on-rails/validatious/remote_validator.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+require File.join(File.dirname(__FILE__), 'validator')
+
+module ValidatiousOnRails
+  module Validatious
+    class RemoteValidator < Validator
+      
+      def initialize(name, *args)
+        super
+      end
+      
+      # TODO: Implement server side validator class, i.e. for validatios that requires AJAX
+      
+      # Idea:
+      #   
+      #   Perform AJAX-request to a specified/generated URL
+      #   (e.g. /validatious/unique?model=article&attribute=...&value=...), with an attached
+      #   callback-method that should trigger a client-side validation.
+      #   Well, this is one possible approach...
+      #
+      
+    end
+  end
+end

data/lib/validatious-on-rails/validatious/validator.rb

@@ -0,0 +1,228 @@
+# encoding: utf-8
+
+# Ruby-representation of a custom Validatious validator ("v2.Validator").
+#
+# Example (JavaScript representation):
+#
+#   v2.Validator.add(
+#     name: 'validator-name',
+#     message: 'Default error message',
+#     params: ['a', 'list', 'of', 'named', 'parameters'],
+#     aliases: ['list', 'of', 'alternative', 'names'],
+#     acceptEmpty: true,
+#     fn: function(field, value, params) {
+#       // Should return true if field/value is valid
+#     }
+#   });
+# 
+module ValidatiousOnRails
+  module Validatious
+    class Validator
+
+      # Reference: http://validatious.org/learn/features/core/custom_validators
+
+      ValidatorError = ::Class.new(::StandardError) unless defined?(ValidatorError)
+
+      attr_accessor :name
+      attr_writer   :message,
+                    :params,
+                    :aliases,
+                    :accept_empty,
+                    :fn
+
+      def initialize(name, options = {})
+        raise ValidatorError, "Parameter :name is required for an Validatious validator" unless name.present?
+        self.name = name
+        options.each do |attr, value|
+          self.send(:"#{attr}=", value) if value.present?
+        end
+      end
+
+      # The primary name of the validator. This is the name you use with v2.$v('name');
+      # and v2.Validator.get('name'); (core API), "field".is("name"); (DSL API) and
+      # class="name" (HTML extension).
+      #
+      # Parameter is required.
+      #
+      # def name
+      #   @name
+      # end
+
+      # This is the default error message. It may use named parameters.
+      # Parameters can be interpolated into the default message through ${param-name}.
+      # All messages have access to ${field}, which resolves to the field name of 
+      # he validated field.
+      #
+      # If the validator takes any parameters, they can also be interpolated into the
+      # message, through the name given through the params parameter.
+      #
+      def message
+        @message ||= ''
+      end
+
+      # The params parameter provides a mapping between any parameters being sent to
+      # the validation method and names to refer to them by when interpolating in the
+      # error message.
+      #
+      # Example: If the fn function uses the value in params[0], you may give this a
+      # name by setting params: ['myparam']. In the error message you can then do
+      # message: "${field} should obey ${myparam}". When a field fails this message,
+      # ${field} will be replaced with the field name, and ${myparam} with the value
+      # of the validator function's params[0].
+      #
+      def params
+        @params ||= []
+      end
+
+      # An array of additional names for the validator. May make sense especially for
+      # the DSL API to be able to refer to a validator by different names.
+      #
+      def aliases
+        @aliases ||= []
+      end
+
+      # Decides if the validator should pass (return true) when the value is empty.
+      # This is usually a good idea because you can leave it up to the required validator
+      # to specifically check for emptiness. One benefit of this approach is more 
+      # fine grained error reporting, helping the user.
+      #
+      # Default value is: true.
+      #
+      def accept_empty
+        @accept_empty.nil? ? true : @accept_empty
+      end
+
+      # This is the method that performs the validation. It receives three arguments,
+      # the last one (parameters) may be empty.
+      #
+      # 1. field is an instance of v2.InputElement, or one of its subclasses. It wraps a
+      # label and one or more input/select/textarea elements, and provides convenience
+      # such as getValue, getLabel, getName, setName, visible and getParent.
+      #
+      # 2. value is basically the value of field.getValue(). There is some overhead in
+      # fetching the value, and since Validatious already uses it, it passes it along,
+      # allowing for an ever so small performance gain.
+      #
+      # 3. params is an array of parameters registered with the field validator. In the
+      # HTML extension, these are the values separated by underscores:
+      # class="myval_1" (params[0] === 1).
+      #
+      # Parameter is required.
+      #
+      def fn=(value)
+        # Handle either full function definition, or just the function body - just because.
+        @fn = if (value =~ /function\(\w*,\w*,\w*\).*\{.*\}/i)
+          value
+        else
+          value ||= ''
+          # If no function specified yet, always validate true by default.
+          value << "\nreturn true;" unless value =~ /return (.+)/i
+          "function(field, value, params) {#{value}}"
+        end
+      end
+
+      def fn
+        (@fn ||= "function(field, value, params) {return true;}").gsub(/[\n\t]/, '')
+      end
+
+      def to_s
+        options = {
+            :name => self.name,
+            :message => self.message,
+            :params => self.params,
+            :aliases => self.aliases,
+            :acceptEmpty => self.accept_empty,
+            :fn => self.fn
+          }
+        # Just to make the tests much DRYer and maintanable on Ruby 1.8
+        # - hash ordered by key only 1.9. ='(
+        js_options = options.keys.collect(&:to_s).sort.collect { |k|
+            v = options[k.to_sym]
+            ("#{k}: #{k.to_sym == :fn ? v : v.to_json}" if [false, true].include?(v) || v.present?)
+          }.compact.join(', ')
+        "v2.Validator.add({#{js_options}});"
+      end
+
+      class << self
+
+        # Generate a unique valdiator ID to avoid clashes.
+        # Note: Ruby #hash is way faster than SHA1 (etc.) - just replace any negative sign.
+        #
+        def generate_id(value)
+          value.to_s.hash.to_s.tr('-', '1')
+        end
+
+        # Any named specified for this custom validation?
+        # E.g. validates_format_of :name, :with => /\d{6}-\d{4}/, :name => 'ssn-se'
+        #
+        # If not, create one that's uniqe based on validation and what to validate based on,
+        # e.g. validates_format_of :name, :with => /\d{6}-\d{4}/ # => :name => "format_with_#{hash-of-:with-value}"
+        #
+        def generate_name(validation, id_key, id_value = nil)
+          # Avoiding duplicates...
+          identifier = "-#{id_value}" if id_value.present?
+          validator_id = "#{validation.macro.to_s.sub(/^validates_/, '').sub(/_of/, '')}_#{id_key}#{identifier}"
+          name = validation.options[:name].present? ? validation.options[:name] : validator_id
+          # "_" is not allowed in name/alias(es) - used to seperate validator-id from it's args/params.
+          [name, validator_id].collect! { |v| v.tr('_', '-') }
+        end
+
+        # Generate proper error message using explicit message, or I18n-lookup.
+        # Core validations gets treated by Rails - unless explicit message is set that is.
+        #
+        # NOTE: Might refactor this into a even more abstract class/module.
+        #
+        def generate_message(validation, *args)
+          options = args.extract_options!
+          explicit_message = validation.options[:message]
+          key = options.delete(:key) || (explicit_message if explicit_message.is_a?(::Symbol))
+
+          message = if key.present?
+            ::I18n.t(key, options.merge(:scope => :'activerecord.errors.messages',
+              :default => "activerecord.errors.messages.#{key}"))
+          elsif explicit_message.is_a?(::String)
+            explicit_message
+          else
+            unless ::ValidatiousOnRails::ModelValidations::CORE_VALIDATIONS.include?(validation.macro.to_sym)
+              # No core validation, try to make up a descent I18n lookup path using conventions.
+              key ||= validation.macro.to_s.tr('-', '_').gsub(/^validates?_/, '').gsub(/_of/, '').to_sym
+              ::I18n.t(key, options.merge(:scope => :'activerecord.errors.messages',
+                :default => "activerecord.errors.messages.#{key}"))
+            else
+              # Nothing - let Rails rails handle the core validation message translations (I18n).
+            end
+          end
+          # Rails I18n interpolations => Validatious interpolations
+          # Example: {{count}} => ${count}
+          message.gsub(/\{\{/, '${').gsub(/\}\}/, '}')
+        end
+
+        # Rails core validation messages:
+        #
+        # messages:
+        #   inclusion: "is not included in the list"
+        #   exclusion: "is reserved"
+        #   invalid: "is invalid"
+        #   confirmation: "doesn't match confirmation"
+        #   accepted: "must be accepted"
+        #   empty: "can't be empty"
+        #   blank: "can't be blank"
+        #   too_long: "is too long (maximum is {{count}} characters)"
+        #   too_short: "is too short (minimum is {{count}} characters)"
+        #   wrong_length: "is the wrong length (should be {{count}} characters)"
+        #   taken: "has already been taken"
+        #   not_a_number: "is not a number"
+        #   greater_than: "must be greater than {{count}}"
+        #   greater_than_or_equal_to: "must be greater than or equal to {{count}}"
+        #   equal_to: "must be equal to {{count}}"
+        #   less_than: "must be less than {{count}}"
+        #   less_than_or_equal_to: "must be less than or equal to {{count}}"
+        #   odd: "must be odd"
+        #   even: "must be even"
+        #   record_invalid: "is invalid"
+
+      end
+
+    end
+  end
+end

data/lib/validatious-on-rails/validatious/validators/exclusion_validator.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+require File.expand_path(File.join(File.dirname(__FILE__), *%w[.. validator]))
+
+# TODO: See notes in FormatValidator.
+#
+module ValidatiousOnRails
+  module Validatious
+    class ExclusionValidator < ClientSideValidator
+
+      def initialize(validation, options = {})
+        name, alias_name = self.class.generate_name(validation, :in, self.class.generate_id(validation.options[:in].inspect))
+        super name, options
+        self.aliases = [alias_name] - [name]
+        self.message = self.class.generate_message(validation)
+        self.accept_empty = validation.options[:allow_blank] || validation.options[:allow_nil]
+        self.fn = %{
+          var exclusion_values = #{validation.options[:in].to_json};
+          for (var i = 0; i < exclusion_values.length; i++) {
+            if (exclusion_values[i] == value) { return false; }
+          };
+          return true;
+        }
+        self.fn.freeze
+      end
+
+    end
+  end
+end

data/lib/validatious-on-rails/validatious/validators/format_validator.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+require File.expand_path(File.join(File.dirname(__FILE__), *%w[.. validator]))
+
+# TODO: Would be "cool" if each format rule was save as a JS var,
+# and referenced with class Validatious style:
+#
+#   <head>:
+#     var ssn-se = /^\d{6}-{4}$/;
+#     <<< format validator here >>>
+#   <body>:
+#     <input type="text" class="format-with_ssn-se" ... />
+#
+# Same for inclusion/exclusion too. Easy to implement, but low prio.
+#
+module ValidatiousOnRails
+  module Validatious
+    class FormatValidator < ClientSideValidator
+
+      def initialize(validation, options = {})
+        name, alias_name = self.class.generate_name(validation, :with, self.class.generate_id(validation.options[:with].inspect))
+        super name, options
+        self.aliases = [alias_name] - [name]
+        self.message = self.class.generate_message(validation)
+        self.accept_empty = validation.options[:allow_blank] || validation.options[:allow_nil]
+        self.fn = %{
+          return #{validation.options[:with].inspect}.test(value);
+        }
+        self.fn.freeze
+      end
+
+    end
+  end
+end

data/lib/validatious-on-rails/validatious/validators/inclusion_validator.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+require File.expand_path(File.join(File.dirname(__FILE__), *%w[.. validator]))
+
+# TODO: See notes in FormatValidator.
+#
+module ValidatiousOnRails
+  module Validatious
+    class InclusionValidator < ClientSideValidator
+
+      def initialize(validation, options = {})
+        name, alias_name = self.class.generate_name(validation, :in, self.class.generate_id(validation.options[:in].inspect))
+        super name, options
+        self.aliases = [alias_name] - [name]
+        self.message = self.class.generate_message(validation)
+        self.accept_empty = validation.options[:allow_blank] || validation.options[:allow_nil]
+        self.fn = %{
+          var inclusion_values = #{validation.options[:in].to_json};
+          for (var i = 0; i < inclusion_values.length; i++) {
+            if (inclusion_values[i] == value) { return true; }
+          };
+          return false;
+        }
+        self.fn.freeze
+      end
+
+    end
+  end
+end

data/lib/validatious-on-rails/validatious/validators/length/is_validator.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+require File.expand_path(File.join(File.dirname(__FILE__), *%w[.. .. validator]))
+
+module ValidatiousOnRails
+  module Validatious
+    module Length
+      class IsValidator < ClientSideValidator
+
+        def initialize(validation, options = {})
+          name, alias_name = self.class.generate_name(validation, :is, validation.options[:is])
+          name = 'length-is'
+          super name, options
+          self.aliases = [alias_name] - [name]
+          self.params = ['count']
+          self.message = self.class.generate_message(validation, :key => :wrong_length)
+          self.accept_empty = validation.options[:allow_blank] || validation.options[:allow_nil]
+          self.fn = %{
+            value += '';
+            return value == params[0];
+          }
+          self.fn.freeze
+        end
+
+      end
+    end
+  end
+end

data/lib/validatious-on-rails/validatious/validators/length/maximum_validator.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+require File.expand_path(File.join(File.dirname(__FILE__), *%w[.. .. validator]))
+
+module ValidatiousOnRails
+  module Validatious
+    module Length
+      class MaximumValidator < ClientSideValidator
+
+        def initialize(validation, options = {})
+          name, alias_name = self.class.generate_name(validation, :maximum, validation.options[:maximum])
+          name = 'length-maximum'
+          super name, options
+          self.aliases = [alias_name] - [name]
+          self.params = ['count']
+          self.message = self.class.generate_message(validation, :key => :too_long)
+          self.accept_empty = validation.options[:allow_blank] || validation.options[:allow_nil]
+          self.fn = %{
+            value += '';
+            return value.length <= params[0];
+          }
+          self.fn.freeze
+        end
+
+      end
+    end
+  end
+end

data/lib/validatious-on-rails/validatious/validators/length/minimum_validator.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+require File.expand_path(File.join(File.dirname(__FILE__), *%w[.. .. validator]))
+
+module ValidatiousOnRails
+  module Validatious
+    module Length
+      class MinimumValidator < ClientSideValidator
+
+        def initialize(validation, options = {})
+          name, alias_name = self.class.generate_name(validation, :minimum, validation.options[:minimum])
+          name = 'length-minimum'
+          super name, options
+          self.aliases = [alias_name] - [name]
+          self.params = ['count']
+          self.message = self.class.generate_message(validation, :key => :too_short)
+          self.accept_empty = validation.options[:allow_blank] || validation.options[:allow_nil]
+          self.fn = %{
+            value += '';
+            return value.length >= params[0];
+          }
+          self.fn.freeze
+        end
+
+      end
+    end
+  end
+end

data/lib/validatious-on-rails/validatious/validators/numericality/equal_to_validator.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+require File.expand_path(File.join(File.dirname(__FILE__), *%w[.. .. validator]))
+
+module ValidatiousOnRails
+  module Validatious
+    module Numericality
+      class EqualToValidator < ClientSideValidator
+
+        def initialize(validation, options = {})
+          name = 'numericality-equal-to'
+          super name, options
+          self.params = ['count']
+          self.message = self.class.generate_message(validation, :key => :equal_to)
+          self.accept_empty = validation.options[:allow_nil]
+          self.fn = %{
+            value = +value;
+            return value == params[0];
+          }
+          self.fn.freeze
+        end
+
+      end
+    end
+  end
+end

data/lib/validatious-on-rails/validatious/validators/numericality/even_validator.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+require File.expand_path(File.join(File.dirname(__FILE__), *%w[.. .. validator]))
+
+module ValidatiousOnRails
+  module Validatious
+    module Numericality
+      class EvenValidator < ClientSideValidator
+
+        def initialize(validation, options = {})
+          name = 'numericality-even'
+          super name, options
+          self.message = self.class.generate_message(validation, :key => :even)
+          self.accept_empty = validation.options[:allow_nil]
+          self.fn = %{
+            value = +value;
+            return (value % 2) == 0;
+          }
+          self.fn.freeze
+        end
+
+      end
+    end
+  end
+end

data/lib/validatious-on-rails/validatious/validators/numericality/greater_than_or_equal_to_validator.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+require File.expand_path(File.join(File.dirname(__FILE__), *%w[.. .. validator]))
+
+module ValidatiousOnRails
+  module Validatious
+    module Numericality
+      class GreaterThanOrEqualToValidator < ClientSideValidator
+
+        def initialize(validation, options = {})
+          name = 'numericality-greater-than-or-equal-to'
+          super name, options
+          self.params = ['count']
+          self.message = self.class.generate_message(validation, :key => :greater_than_or_equal_to)
+          self.accept_empty = validation.options[:allow_nil]
+          self.fn = %{
+            value = +value;
+            return value >= params[0];
+          }
+          self.fn.freeze
+        end
+
+      end
+    end
+  end
+end

data/lib/validatious-on-rails/validatious/validators/numericality/greater_than_validator.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+require File.expand_path(File.join(File.dirname(__FILE__), *%w[.. .. validator]))
+
+module ValidatiousOnRails
+  module Validatious
+    module Numericality
+      class GreaterThanValidator < ClientSideValidator
+
+        def initialize(validation, options = {})
+          name = 'numericality-greater-than'
+          super name, options
+          self.params = ['count']
+          self.message = self.class.generate_message(validation, :key => :greater_than)
+          self.accept_empty = validation.options[:allow_nil]
+          self.fn = %{
+            value = +value;
+            return value > params[0];
+          }
+          self.fn.freeze
+        end
+
+      end
+    end
+  end
+end

data/lib/validatious-on-rails/validatious/validators/numericality/less_than_or_equal_to_validator.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+require File.expand_path(File.join(File.dirname(__FILE__), *%w[.. .. validator]))
+
+module ValidatiousOnRails
+  module Validatious
+    module Numericality
+      class LessThanOrEqualToValidator < ClientSideValidator
+
+        def initialize(validation, options = {})
+          name = 'numericality-less-than-or-equal-to'
+          super name, options
+          self.params = ['count']
+          self.message = self.class.generate_message(validation, :key => :less_than_or_equal_to)
+          self.accept_empty = validation.options[:allow_nil]
+          self.fn = %{
+            value = +value;
+            return value <= params[0];
+          }
+          self.fn.freeze
+        end
+
+      end
+    end
+  end
+end

data/lib/validatious-on-rails/validatious/validators/numericality/less_than_validator.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+require File.expand_path(File.join(File.dirname(__FILE__), *%w[.. .. validator]))
+
+module ValidatiousOnRails
+  module Validatious
+    module Numericality
+      class LessThanValidator < ClientSideValidator
+
+        def initialize(validation, options = {})
+          name = 'numericality-less-than'
+          super name, options
+          self.params = ['count']
+          self.message = self.class.generate_message(validation, :key => :less_than)
+          self.accept_empty = validation.options[:allow_nil]
+          self.fn = %{
+            value = +value;
+            return value < params[0];
+          }
+          self.fn.freeze
+        end
+
+      end
+    end
+  end
+end

data/lib/validatious-on-rails/validatious/validators/numericality/odd_validator.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+require File.expand_path(File.join(File.dirname(__FILE__), *%w[.. .. validator]))
+
+module ValidatiousOnRails
+  module Validatious
+    module Numericality
+      class OddValidator < ClientSideValidator
+
+        def initialize(validation, options = {})
+          name = 'numericality-odd'
+          super name, options
+          self.message = self.class.generate_message(validation, :key => :odd)
+          self.accept_empty = validation.options[:allow_nil]
+          self.fn = %{
+            value = +value;
+            return (value % 2) == 1;
+          }
+          self.fn.freeze
+        end
+
+      end
+    end
+  end
+end

data/lib/validatious-on-rails/validatious/validators/numericality/only_integer_validator.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+require File.expand_path(File.join(File.dirname(__FILE__), *%w[.. .. validator]))
+
+module ValidatiousOnRails
+  module Validatious
+    module Numericality
+      class OnlyIntegerValidator < ClientSideValidator
+
+        def initialize(validation, options = {})
+          name = 'numericality-only_integer'
+          super name, options
+          self.message = self.class.generate_message(validation, :key => :not_a_number)
+          self.accept_empty = validation.options[:allow_nil]
+          self.fn = %{
+            value = +value;
+            return /\A[+-]?\d+\Z/.test(value);
+          }
+          self.fn.freeze
+        end
+
+      end
+    end
+  end
+end

data/lib/validatious-on-rails/validatious/validators.rb

@@ -0,0 +1,3 @@
+Dir.glob(File.join(File.dirname(__FILE__), 'validators', '**', '*.rb').to_s).each do |validator|
+  require validator
+end

data/lib/validatious-on-rails/validatious.rb

@@ -0,0 +1,5 @@
+# encoding: utf-8
+require File.join(File.dirname(__FILE__), *%w[validatious validator])
+require File.join(File.dirname(__FILE__), *%w[validatious client_side_validator])
+require File.join(File.dirname(__FILE__), *%w[validatious remote_validator])
+require File.join(File.dirname(__FILE__), *%w[validatious validators])