errapi 0.1.0 → 0.1.2

data/lib/errapi/single_validator.rb

@@ -0,0 +1,19 @@
+module Errapi
+
+  class SingleValidator
+
+    def self.configure *args, &block
+
+      options = args.last.kind_of?(Hash) ? args.pop : {}
+      config = options[:config] || Errapi.config
+      config = Errapi.config config if config.kind_of? Symbol
+
+      @errapi_validator = ObjectValidator.new config, options, &block
+    end
+
+    def self.validate *args, &block
+      raise "Validator has not yet been configured. You must call #configure before calling #validate." unless @errapi_validator
+      @errapi_validator.validate *args, &block
+    end
+  end
+end

data/lib/errapi/utils.rb

@@ -0,0 +1,12 @@
+module Errapi::Utils
+
+  def self.camelize string, uppercase_first_letter = false
+    parts = string.split '_'
+    return string if parts.length < 2
+    parts[0] + parts[1, parts.length - 1].collect(&:capitalize).join
+  end
+
+  def self.underscore string
+    string.gsub(/::/, '/').gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').gsub(/([a-z\d])([A-Z])/,'\1_\2').tr("-", "_").downcase
+  end
+end

data/lib/errapi/validation_context.rb

@@ -0,0 +1,49 @@
+require 'ostruct'
+
+class Errapi::ValidationContext
+  attr_reader :data
+  attr_reader :errors
+  attr_reader :config
+
+  def initialize options = {}
+    @errors = []
+    @data = OpenStruct.new options[:data] || {}
+    @config = options[:config]
+  end
+
+  def add_error options = {}, &block
+
+    error = options.kind_of?(Errapi::ValidationError) ? options : @config.new_error(options)
+    yield error if block_given?
+    @config.build_error error, self
+
+    @errors << error
+    self
+  end
+
+  def errors? criteria = {}, &block
+    return !@errors.empty? if criteria.empty? && !block
+    block ? @errors.any?{ |err| err.matches?(criteria) && block.call(err) } : @errors.any?{ |err| err.matches?(criteria) }
+  end
+
+  def valid?
+    !errors?
+  end
+
+  def clear
+    @errors.clear
+    @data = OpenStruct.new
+  end
+
+  # TODO: add custom serialization options
+  def serialize
+    # TODO: add hook for plugins to serialize context
+    { errors: [] }.tap do |h|
+      @errors.each do |error|
+        serialized = {}
+        @config.serialize_error error, serialized
+        h[:errors] << serialized
+      end
+    end
+  end
+end

data/lib/errapi/validation_error.rb

@@ -0,0 +1,43 @@
+require 'ostruct'
+
+class Errapi::ValidationError
+  attr_accessor :reason
+  attr_accessor :check_value
+  attr_accessor :checked_value
+  attr_accessor :validation
+  attr_accessor :constraints
+  attr_accessor :location
+
+  def initialize options = {}
+    ATTRIBUTES.each do |attr|
+      instance_variable_set "@#{attr}", options[attr] if options.key? attr
+    end
+  end
+
+  def matches? criteria = {}
+    unknown_criteria = criteria.keys - ATTRIBUTES
+    raise "Unknown error attributes: #{unknown_criteria.join(', ')}." if unknown_criteria.any?
+    ATTRIBUTES.all?{ |attr| criterion_matches? criteria, attr }
+  end
+
+  private
+
+  ATTRIBUTES = %i(reason location check_value checked_value validation)
+
+  def criterion_matches? criteria, attr
+    return true unless criteria.key? attr
+
+    value = send attr
+    criterion = criteria[attr]
+
+    if criterion.kind_of? Regexp
+      !!criterion.match(value.to_s)
+    elsif criterion.kind_of? String
+      criterion == value.to_s
+    elsif criterion.respond_to? :===
+      criterion === value
+    else
+      criterion == value
+    end
+  end
+end

data/lib/errapi/validations/clusivity.rb

@@ -0,0 +1,45 @@
+module Errapi::Validations
+  module Clusivity
+    private
+
+    DELIMITER_METHOD_CHECKS = %i(include? call to_sym).freeze
+
+    def check_delimiter! option_desc
+      unless @delimiter.respond_to?(:include?) || callable_option_value?(@delimiter)
+        raise callable_option_type_error option_desc, "an object with the #include? method", @delimiter
+      end
+    end
+
+    def members option_desc, options = {}
+      enumerable = actual_option_value @delimiter, options
+
+      unless enumerable.respond_to? :include?
+        raise callable_option_value_error option_desc, "an object with the #include? method", @delimiter
+      end
+
+      enumerable
+    end
+
+    def include? members, value
+      members.send inclusion_method(members), value
+    end
+
+    # From rails/activemodel/lib/active_model/validations/clusivity.rb:
+    # In Ruby 1.9 <tt>Range#include?</tt> on non-number-or-time-ish ranges checks all
+    # possible values in the range for equality, which is slower but more accurate.
+    # <tt>Range#cover?</tt> uses the previous logic of comparing a value with the range
+    # endpoints, which is fast but is only accurate on Numeric, Time, or DateTime ranges.
+    def inclusion_method enumerable
+      if enumerable.is_a? Range
+        case enumerable.first
+        when Numeric, Time, DateTime
+          :cover?
+        else
+          :include?
+        end
+      else
+        :include?
+      end
+    end
+  end
+end

data/lib/errapi/validations/exclusion.rb

@@ -0,0 +1,28 @@
+require File.join(File.dirname(__FILE__), 'clusivity.rb')
+
+module Errapi::Validations
+  class Exclusion < Base
+    include Clusivity
+
+    def initialize options = {}
+      unless key = exactly_one_option?(OPTIONS, options)
+        raise ArgumentError, "Either :from or :in or :within must be supplied (but only one of them)."
+      end
+
+      @delimiter = options[key]
+      check_delimiter! OPTIONS_DESCRIPTION
+    end
+
+    def validate value, context, options = {}
+      excluded_values = members OPTIONS_DESCRIPTION, options
+      if include? excluded_values, value
+        context.add_error reason: :excluded, check_value: excluded_values
+      end
+    end
+
+    private
+
+    OPTIONS = %i(from in within)
+    OPTIONS_DESCRIPTION = ":from (or :in or :within)"
+  end
+end

data/lib/errapi/validations/format.rb

@@ -0,0 +1,33 @@
+module Errapi::Validations
+  class Format < Base
+
+    def initialize options = {}
+      unless key = exactly_one_option?(OPTIONS, options)
+        raise ArgumentError, "Either :with or :without must be supplied (but not both)."
+      end
+
+      @format = options[key]
+      @should_match = key == :with
+
+      unless @format.kind_of?(Regexp) or callable_option_value?(@format)
+        raise callable_option_type_error ":with (or :without)", "a regular expression", @format
+      end
+    end
+
+    def validate value, context, options = {}
+
+      regexp = actual_option_value @format, options
+      unless regexp.kind_of? Regexp
+        raise callable_option_value_error ":with (or :without)", "a regular expression", regexp
+      end
+
+      if !regexp.match(value.to_s) == @should_match
+        context.add_error reason: :invalid_format, check_value: regexp
+      end
+    end
+
+    private
+
+    OPTIONS = %i(with without)
+  end
+end

data/lib/errapi/validations/inclusion.rb

@@ -0,0 +1,28 @@
+require File.join(File.dirname(__FILE__), 'clusivity.rb')
+
+module Errapi::Validations
+  class Inclusion < Base
+    include Clusivity
+
+    def initialize options = {}
+      unless key = exactly_one_option?(OPTIONS, options)
+        raise ArgumentError, "Either :in or :within must be supplied (but not both)."
+      end
+
+      @delimiter = options[key]
+      check_delimiter! OPTIONS_DESCRIPTION
+    end
+
+    def validate value, context, options = {}
+      allowed_values = members OPTIONS_DESCRIPTION, options
+      unless include? allowed_values, value
+        context.add_error reason: :not_included, check_value: allowed_values
+      end
+    end
+
+    private
+
+    OPTIONS = %i(in within)
+    OPTIONS_DESCRIPTION = ":in (or :within)"
+  end
+end

data/lib/errapi/validations/length.rb

@@ -0,0 +1,66 @@
+module Errapi::Validations
+  class Length < Base
+    CHECKS = { is: :==, minimum: :>=, maximum: :<= }.freeze
+    REASONS = { is: :wrong_length, minimum: :too_short, maximum: :too_long }.freeze
+
+    def initialize options = {}
+
+      constraints = options.select{ |k,v| OPTIONS.include? k }
+      if constraints.empty?
+        raise ArgumentError, "The :is, :minimum/:maximum or :within options must be supplied (but only :minimum and :maximum can be used together)."
+      elsif options.key?(:is) && constraints.length != 1
+        raise ArgumentError, "The :is option cannot be combined with :minimum, :maximum or :within."
+      elsif options.key?(:is)
+        check_numeric! options[:is]
+      elsif options.key?(:within)
+        if options.key?(:minimum) || options.key?(:maximum)
+          raise ArgumentError, "The :within option cannot be combined with :minimum or :maximum."
+        else
+          check_range! options[:within]
+        end
+      else
+        check_numeric! options[:minimum] if options.key? :minimum
+        check_numeric! options[:maximum] if options.key? :maximum
+      end
+
+      @constraints = actual_constraints constraints
+    end
+
+    def validate value, context, options = {}
+      return unless value.respond_to? :length
+      actual_length = value.length
+
+      CHECKS.each_pair do |key,check|
+        next unless check_value = @constraints[key]
+        next if actual_length.send check, check_value
+        context.add_error reason: REASONS[key], check_value: check_value, checked_value: actual_length, constraints: @constraints
+      end
+    end
+
+    private
+
+    OPTIONS = %i(is minimum maximum within)
+
+    def actual_constraints options = {}
+      if range = options[:within]
+        { minimum: range.min, maximum: range.max }
+      else
+        options
+      end
+    end
+
+    def check_numeric! bound
+      unless bound.kind_of? Numeric
+        raise ArgumentError, "The :is, :minimum or :maximum option must be a numeric value, but a #{bound.class.name} was given."
+      end
+    end
+
+    def check_range! range
+      if !range.kind_of?(Range)
+        raise ArgumentError, "The :within option must be a numeric range, but a #{range.class.name} was given."
+      elsif !(t = range.first).kind_of?(Numeric)
+        raise ArgumentError, "The :within option must be a numeric range, but a #{t.class.name} range was given."
+      end
+    end
+  end
+end

data/lib/errapi/validations/presence.rb

@@ -0,0 +1,39 @@
+module Errapi::Validations
+  class Presence < Factory
+    class Implementation < Base
+
+      def validate value, context, options = {}
+        if reason = check(value, options.fetch(:value_set, true))
+          context.add_error reason: reason
+        end
+      end
+
+      private
+
+      BLANK_REGEXP = /\A[[:space:]]*\z/
+
+      def check value, value_set
+        # TODO: allow customization (e.g. values that are not required, booleans, etc)
+        if !value_set
+          :missing
+        elsif value.nil?
+          :null
+        elsif value.respond_to?(:empty?) && value.empty?
+          :empty
+        elsif value_blank? value
+          :blank
+        end
+      end
+
+      def value_blank? value
+        if value.respond_to? :blank?
+          value.blank?
+        elsif value.kind_of? String
+          BLANK_REGEXP === value
+        else
+          false
+        end
+      end
+    end
+  end
+end

data/lib/errapi/validations/trim.rb

@@ -0,0 +1,10 @@
+module Errapi::Validations
+  class Trim < Base
+
+    def validate value, context, options = {}
+      if value.kind_of?(String) && /(?:\A\s|\s\Z)/.match(value)
+        context.add_error reason: :untrimmed
+      end
+    end
+  end
+end

data/lib/errapi/validations/type.rb

@@ -0,0 +1,54 @@
+module Errapi::Validations
+  class Type < Base
+
+    def initialize options = {}
+      unless key = exactly_one_option?(OPTIONS, options)
+        raise ArgumentError, "One option among :instance_of, :kind_of, :is_a or :is_an must be supplied (but only one)."
+      end
+
+      if key == :instance_of
+        @instance_of = check_types! options[key]
+        raise ArgumentError, "Type aliases cannot be used with the :instance_of option. Use :kind_of, :is_a or :is_an." if options[key].kind_of? Symbol
+      else
+        @kind_of = check_types! options[key]
+      end
+    end
+
+    def validate value, context, options = {}
+      if @instance_of && @instance_of.none?{ |type| value.instance_of? type }
+        context.add_error reason: :wrong_type, check_value: @instance_of, checked_value: value.class
+      elsif @kind_of && @kind_of.none?{ |type| value.kind_of? type }
+        context.add_error reason: :wrong_type, check_value: @kind_of, checked_value: value.class
+      end
+    end
+
+    private
+
+    def check_types! types
+      if !types.kind_of?(Array)
+        types = [ types ]
+      elsif types.empty?
+        raise ArgumentError, "At least one class or module is required, but an empty array was given."
+      end
+
+      types.each do |type|
+        unless TYPE_ALIASES.key?(type) || type.class == Class || type.class == Module
+          raise ArgumentError, "A class or module (or an array of classes or modules, or a type alias) is required, but a #{type.class} was given."
+        end
+      end
+
+      types.collect{ |type| TYPE_ALIASES[type] || type }.flatten.uniq
+    end
+
+    OPTIONS = %i(instance_of kind_of is_a is_an)
+    TYPE_ALIASES = {
+      string: [ String ],
+      number: [ Numeric ],
+      integer: [ Integer ],
+      boolean: [ TrueClass, FalseClass ],
+      object: [ Hash ],
+      array: [ Array ],
+      null: [ NilClass ]
+    }
+  end
+end

data/lib/errapi/validations.rb

@@ -0,0 +1,57 @@
+module Errapi::Validations
+
+  class Base
+
+    def initialize options = {}
+    end
+
+    def actual_option_value supplied_value, options
+      if supplied_value.respond_to? :call
+        supplied_value.call options[:source]
+      elsif supplied_value.respond_to? :to_sym
+        unless options[:source].respond_to? supplied_value
+          raise ArgumentError, "The validation source (#{options[:source].class.name}) does not respond to :#{supplied_value}."
+        else
+          options[:source].send supplied_value
+        end
+      else
+        supplied_value
+      end
+    end
+
+    def callable_option_value? supplied_value
+      supplied_value.respond_to?(:call) || supplied_value.respond_to?(:to_sym)
+    end
+
+    def exactly_one_option? keys, options
+      found_keys = options.keys.select{ |k| keys.include? k }
+      found_keys.length == 1 ? found_keys.first : false
+    end
+
+    def callable_option_type_error key_desc, value_desc, supplied_value
+      ArgumentError.new "The #{key_desc} option must be #{value_desc}, a proc, a lambda or a symbol, but a #{supplied_value.class.name} was given."
+    end
+
+    def callable_option_value_error key_desc, type_desc, supplied_value
+      ArgumentError.new "The call supplied to #{key_desc} must return #{type_desc}, but a #{supplied_value.class.name} was returned."
+    end
+  end
+
+  class Factory
+
+    def config= config
+      raise "A configuration has already been set for this factory." if @config
+      @config = config
+    end
+
+    def validation options = {}
+      self.class.const_get('Implementation').new options
+    end
+
+    def to_s
+      Errapi::Utils.underscore self.class.name.sub(/.*::/, '')
+    end
+  end
+end
+
+Dir[File.join File.dirname(__FILE__), File.basename(__FILE__, '.*'), '*.rb'].each{ |lib| require lib }

data/lib/errapi/validator_proxy.rb

@@ -0,0 +1,21 @@
+module Errapi
+
+  class ValidatorProxy
+    instance_methods.each{ |m| undef_method m unless m =~ /(^__|^send$|^object_id$)/ }
+
+    def initialize object, validator
+      @object = object
+      @validator = validator
+    end
+
+    def validate context, options = {}
+      @validator.validate @object, context, options
+    end
+
+    protected
+
+    def method_missing name, *args, &block
+      @validator.send name, *args, &block
+    end
+  end
+end

data/lib/errapi.rb

@@ -1,3 +1,47 @@
 module Errapi
-  VERSION = '0.1.0'
+  VERSION = '0.1.2'
+end
+
+Dir[File.join File.dirname(__FILE__), File.basename(__FILE__, '.*'), '*.rb'].each{ |lib| require lib }
+
+module Errapi
+
+  def self.configure name = nil, &block
+
+    init_configs
+    name ||= :default
+
+    if @configs[name]
+      @configs[name].configure &block
+    else
+      @configs[name] = Configuration.new &block
+    end
+  end
+
+  def self.config name = nil
+    init_configs[name || :default]
+  end
+
+  private
+
+  def self.init_configs
+    @configs ? @configs : @configs = { default: default_config }
+  end
+
+  def self.default_config
+    Configuration.new.tap do |config|
+      config.plugin Errapi::Plugins::I18nMessages
+      config.plugin Errapi::Plugins::Reason
+      config.plugin Errapi::Plugins::Location
+      config.validation_factory Errapi::Validations::Exclusion
+      config.validation_factory Errapi::Validations::Format
+      config.validation_factory Errapi::Validations::Inclusion
+      config.validation_factory Errapi::Validations::Length
+      config.validation_factory Errapi::Validations::Presence.new
+      config.validation_factory Errapi::Validations::Trim
+      config.validation_factory Errapi::Validations::Type
+      config.register_condition Errapi::Condition::SimpleCheck
+      config.register_condition Errapi::Condition::ErrorCheck
+    end
+  end
 end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: errapi
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - Simon Oulevay
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-09 00:00:00.000000000 Z
+date: 2015-01-26 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: i18n
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.0
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -38,6 +52,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: rspec-collection_matchers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
 - !ruby/object:Gem::Dependency
   name: jeweler
   requirement: !ruby/object:Gem::Requirement
@@ -72,28 +100,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.9'
+        version: 0.9.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.9'
+        version: 0.9.1
 - !ruby/object:Gem::Dependency
   name: coveralls
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.7'
+        version: 0.7.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.7'
+        version: 0.7.3
 description: Utilities to validate data and serialize errors.
 email: git@alphahydrae.com
 executables: []
@@ -107,6 +135,34 @@ files:
 - README.md
 - VERSION
 - lib/errapi.rb
+- lib/errapi/condition.rb
+- lib/errapi/configuration.rb
+- lib/errapi/errors.rb
+- lib/errapi/location_builders.rb
+- lib/errapi/locations.rb
+- lib/errapi/locations/dotted.rb
+- lib/errapi/locations/json.rb
+- lib/errapi/locations/none.rb
+- lib/errapi/model.rb
+- lib/errapi/object_validator.rb
+- lib/errapi/plugins.rb
+- lib/errapi/plugins/i18n_messages.rb
+- lib/errapi/plugins/location.rb
+- lib/errapi/plugins/reason.rb
+- lib/errapi/single_validator.rb
+- lib/errapi/utils.rb
+- lib/errapi/validation_context.rb
+- lib/errapi/validation_error.rb
+- lib/errapi/validations.rb
+- lib/errapi/validations/clusivity.rb
+- lib/errapi/validations/exclusion.rb
+- lib/errapi/validations/format.rb
+- lib/errapi/validations/inclusion.rb
+- lib/errapi/validations/length.rb
+- lib/errapi/validations/presence.rb
+- lib/errapi/validations/trim.rb
+- lib/errapi/validations/type.rb
+- lib/errapi/validator_proxy.rb
 homepage: http://github.com/AlphaHydrae/errapi
 licenses:
 - MIT
@@ -127,7 +183,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.3
 signing_key: 
 specification_version: 4
 summary: An extensible API-oriented validation library.