errapi 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9ab7149f96d1f210d259a3ca6aae590426b61709
-  data.tar.gz: d39bce05918e393860e7782e6facaaf7bbb6a4ed
+  metadata.gz: dcae888fc36cd422f1fda237dd5381aa10e776d1
+  data.tar.gz: 757ad4e09cea3666e7279d59d544ff2e99c6bab4
 SHA512:
-  metadata.gz: c66e6b2430d880b18956f1e0d7c2a6adcd6a834926868c611c9db1f7afbc7eea94f0cf4cf4e4a83e7ff515e0a1a8fb7f2807d0a2b50236ac169d447df9708edf
-  data.tar.gz: 0fb04d4565c105414eb21f519f1b74afa3434543ada8c3b6eb09ce486d31e8f93aa367009b820aee612697bcf6ae1b8cb2be92591ddfa8d4e165bb5f5c8479d3
+  metadata.gz: 5fe74be1e6ef55493f04accf713edfc0ce497c982dc84d68e92262bc7183f4d4076fd872d53f15b27a782e7f613054dc76fd8f26c9f2ef95842cfc9bb020c5a3
+  data.tar.gz: 3ff0b1fee2094513a11daf6ef7d8eb12155a23cadcb4d318843d1bb57dbae2e6c4cf570dac8e1015343a50acf928ccaa4c91da8ad3800b4a92075369124d9c2b

data/Gemfile

@@ -1,10 +1,12 @@
 source "https://rubygems.org"
 
 group :development do
+  gem 'i18n', '~> 0.7.0'
   gem 'rake', '~> 10.3'
   gem 'rspec', '~> 3.1'
+  gem 'rspec-collection_matchers', '~> 1.1'
   gem 'jeweler', '~> 2.0'
   gem 'rake-version', '~> 0.4'
-  gem 'simplecov', '~> 0.9'
-  gem 'coveralls', '~> 0.7', require: false
+  gem 'simplecov', '~> 0.9.1'
+  gem 'coveralls', '~> 0.7.3', require: false
 end

data/README.md

@@ -2,10 +2,10 @@
 
 **An extensible API-oriented validation library.**
 
-[![Gem Version](https://badge.fury.io/rb/errapi.png)](http://badge.fury.io/rb/errapi)
+[![Gem Version](https://badge.fury.io/rb/errapi.svg)](http://badge.fury.io/rb/errapi)
 [![Dependency Status](https://gemnasium.com/AlphaHydrae/errapi.png)](https://gemnasium.com/AlphaHydrae/errapi)
 [![Build Status](https://secure.travis-ci.org/AlphaHydrae/errapi.png)](http://travis-ci.org/AlphaHydrae/errapi)
-[![Coverage Status](https://coveralls.io/repos/AlphaHydrae/errapi/badge.png?branch=master)](https://coveralls.io/r/AlphaHydrae/errapi?branch=master)
+[![Coverage Status](https://coveralls.io/repos/AlphaHydrae/errapi/badge.svg)](https://coveralls.io/r/AlphaHydrae/errapi?branch=master)
 
 ## Installation
 
@@ -17,6 +17,10 @@ gem 'errapi', '~> 0.1.0'
 
 Then run `bundle install`.
 
+### Requirements
+
+* Ruby 2+
+
 ## Meta
 
 * **Author:** Simon Oulevay (Alpha Hydrae)

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.1.2

data/lib/errapi/condition.rb

@@ -0,0 +1,71 @@
+class Errapi::Condition
+  ALLOWED_CONDITIONALS = %i(if unless).freeze
+
+  def self.conditionals
+    h = const_get('CONDITIONALS')
+    raise LoadError, "The CONDITIONALS constant in class #{self} is of the wrong type (#{h.class}). Either make it a Hash or override #{self}.conditionals to return a list of symbols." unless h.kind_of? Hash
+    h.keys
+  end
+
+  def initialize conditional, predicate, options = {}
+
+    @conditional = resolve_conditional conditional
+    raise ArgumentError, "Conditional must be either :if or :unless" unless ALLOWED_CONDITIONALS.include? @conditional
+
+    @predicate = predicate
+  end
+
+  def fulfilled? *args
+    result = check @predicate, *args
+    result = !result if @conditional == :unless
+    result
+  end
+
+  def resolve_conditional conditional
+    conditional
+  end
+
+  def check predicate, value, context, options = {}
+    raise NotImplementedError, "Subclasses should implement the #check method to check whether the value matches the predicate of the condition"
+  end
+
+  class SimpleCheck < Errapi::Condition
+
+    CONDITIONALS = {
+      if: :if,
+      unless: :unless
+    }.freeze
+
+    def check predicate, value, context, options = {}
+      if @predicate.kind_of?(Symbol) || @predicate.kind_of?(String)
+        value.respond_to?(:[]) ? value[@predicate] : value.send(@predicate)
+      elsif @predicate.respond_to? :call
+        @predicate.call value, context, options
+      else
+        @predicate
+      end
+    end
+  end
+
+  class ErrorCheck < Errapi::Condition
+
+    CONDITIONALS = {
+      if_error: :if,
+      unless_error: :unless
+    }.freeze
+
+    def resolve_conditional conditional
+      CONDITIONALS[conditional]
+    end
+
+    def check predicate, value, context, options = {}
+      if @predicate.respond_to? :call
+        context.errors? &@predicate
+      elsif @predicate.kind_of? Hash
+        context.errors? @predicate
+      else
+        @predicate ? context.errors? : !context.errors?
+      end
+    end
+  end
+end

data/lib/errapi/configuration.rb

@@ -0,0 +1,79 @@
+require File.join(File.dirname(__FILE__), 'utils.rb')
+
+module Errapi
+
+  class Configuration
+    attr_reader :options
+    attr_reader :plugins
+
+    def initialize
+      @options = OpenStruct.new
+      @plugins = OpenStruct.new
+      @validation_factories = {}
+      @condition_factories = {}
+      @location_factories = {}
+    end
+
+    def configure
+      yield self
+    end
+
+    def new_error options = {}
+      Errapi::ValidationError.new options
+    end
+
+    def build_error error, context
+      apply_plugins :build_error, error, context
+    end
+
+    def serialize_error error, serialized
+      apply_plugins :serialize_error, error, serialized
+    end
+
+    def new_context
+      Errapi::ValidationContext.new config: self
+    end
+
+    def plugin impl, options = {}
+      name = options[:name] || Utils.underscore(impl.to_s.sub(/.*::/, '')).to_sym
+      impl.config = self if impl.respond_to? :config=
+      @plugins[name] = impl
+    end
+
+    def validation_factory factory, options = {}
+      name = options[:name] || Utils.underscore(factory.to_s.sub(/.*::/, '')).to_sym
+      factory.config = self if factory.respond_to? :config=
+      @validation_factories[name] = factory
+    end
+
+    def validation name, options = {}
+      raise ArgumentError, "No validation factory registered for name #{name.inspect}" unless @validation_factories.key? name
+      factory = @validation_factories[name]
+      factory.respond_to?(:validation) ? factory.validation(options) : factory.new(options)
+    end
+
+    def register_condition factory
+      factory.conditionals.each do |conditional|
+        raise ArgumentError, "Conditional #{conditional} should start with 'if' or 'unless'." unless conditional.to_s.match /^(if|unless)/
+        @condition_factories[conditional] = factory
+      end
+    end
+
+    def extract_conditions! source, options = {}
+      [].tap do |conditions|
+        @condition_factories.each_pair do |conditional,factory|
+          next unless source.key? conditional
+          conditions << factory.new(conditional, source.delete(conditional), options)
+        end
+      end
+    end
+
+    private
+
+    def apply_plugins operation, *args
+      @plugins.each_pair do |name,plugin|
+        plugin.send operation, *args if plugin.respond_to? operation
+      end
+    end
+  end
+end

data/lib/errapi/errors.rb

@@ -0,0 +1,15 @@
+module Errapi
+  # TODO: check all "raise" statements and use custom errors
+  class Error < StandardError; end
+  class ValidationErrorInvalid < Error; end
+  class ValidationDefinitionInvalid < Error; end
+
+  class ValidationFailed < Error
+    attr_reader :context
+
+    def initialize context
+      super "#{context.errors.length} errors were found during validation."
+      @context = context
+    end
+  end
+end

data/lib/errapi/location_builders.rb

@@ -0,0 +1,17 @@
+module Errapi
+
+  module LocationBuilders
+
+    def json_location string = nil
+      Locations::Json.new string
+    end
+
+    def dotted_location string = nil
+      Locations::Dotted.new string
+    end
+
+    def no_location
+      Locations::None.instance
+    end
+  end
+end

data/lib/errapi/locations/dotted.rb

@@ -0,0 +1,33 @@
+module Errapi
+
+  class Locations::Dotted
+
+    def initialize location = nil
+      @location = location.to_s.sub /^\./, '' unless location.nil?
+    end
+
+    def relative parts
+      if @location.nil?
+        self.class.new parts
+      else
+        self.class.new "#{@location}.#{parts.to_s.sub(/^\./, '')}"
+      end
+    end
+
+    def location_type
+      :dotted
+    end
+
+    def serialize
+      @location.nil? ? nil : @location
+    end
+
+    def === location
+      @location.to_s == location.to_s
+    end
+
+    def to_s
+      @location.to_s
+    end
+  end
+end

data/lib/errapi/locations/json.rb

@@ -0,0 +1,33 @@
+module Errapi
+
+  class Locations::Json
+
+    def initialize location = nil
+      @location = location.nil? ? '' : "/#{location.to_s.sub(/^\//, '').sub(/\/$/, '')}"
+    end
+
+    def relative parts
+      if @location.nil?
+        self.class.new parts
+      else
+        self.class.new "#{@location}/#{parts.to_s.sub(/^\./, '').sub(/\/$/, '')}"
+      end
+    end
+
+    def location_type
+      :json
+    end
+
+    def serialize
+      @location
+    end
+
+    def === location
+      @location.to_s == location.to_s
+    end
+
+    def to_s
+      @location
+    end
+  end
+end

data/lib/errapi/locations/none.rb

@@ -0,0 +1,28 @@
+require 'singleton'
+
+module Errapi
+
+  class Locations::None
+    include Singleton
+
+    def relative parts
+      self
+    end
+
+    def serialize
+      nil
+    end
+
+    def === location
+      location.nil? || self == location
+    end
+
+    def to_s
+      LOCATION_STRING
+    end
+
+    private
+
+    LOCATION_STRING = ''.freeze
+  end
+end

data/lib/errapi/locations.rb

@@ -0,0 +1,4 @@
+module Errapi::Locations
+end
+
+Dir[File.join File.dirname(__FILE__), File.basename(__FILE__, '.*'), '*.rb'].each{ |lib| require lib }

data/lib/errapi/model.rb

@@ -0,0 +1,30 @@
+module Errapi
+
+  module Model
+
+    def errapi name = :default
+      validator = self.class.errapi name
+      ValidatorProxy.new self, validator
+    end
+
+    def self.included mod
+      mod.extend ClassMethods
+    end
+
+    module ClassMethods
+
+      def errapi *args, &block
+
+        options = args.last.kind_of?(Hash) ? args.pop : {}
+        config = options[:config] || Errapi.config
+        config = Errapi.config config if config.kind_of? Symbol
+
+        name = args.shift || :default
+
+        @errapi_validators ||= {}
+        @errapi_validators[name] = Errapi::ObjectValidator.new(config, &block) if block
+        @errapi_validators[name]
+      end
+    end
+  end
+end

data/lib/errapi/object_validator.rb

@@ -0,0 +1,230 @@
+require File.join(File.dirname(__FILE__), 'location_builders.rb')
+
+module Errapi
+
+  class ObjectValidator
+    include LocationBuilders
+
+    def initialize config, options = {}, &block
+      # TODO: remove these options or if used, pass them to new validators instantiated in #register_validations
+      @config = config
+      @validations = []
+      instance_eval &block if block
+    end
+
+    def validates *args, &block
+      register_validations *args, &block
+    end
+
+    def validates_each *args, &block
+
+      options = args.last.kind_of?(Hash) ? args.pop : {}
+      options[:each] = args.shift
+      options[:each_options] = options.delete(:each_options) || {}
+      args << options
+
+      validates *args, &block
+    end
+
+    def validate value, context, options = {}
+      # TODO: skip validation by default if previous errors at current location
+      # TODO: add support for previous value and skip validation by default if value is unchanged
+
+      return context.valid? unless @validations
+
+      location = if options[:location]
+        options[:location]
+      elsif options[:location_type]
+        builder = "#{options[:location_type]}_location"
+        raise "Unknown location type #{options[:location_type].inspect}" unless respond_to? builder
+        send builder
+      else
+        no_location
+      end
+
+      source = options[:source]
+      context_proxy = ContextProxy.new context, self, location
+
+      @validations.each do |validation_definition|
+
+        each = validation_definition[:each]
+
+        each_values = nil
+        each_values_set = nil
+
+        if each
+          each_values = extract(value, each[:target], options)[:value]
+          each_values_set = each_values.collect{ |v| true } if each_values.kind_of? Array
+          each_values = [] unless each_values.kind_of? Array
+          each_sources = each_values.collect{ |v| source }
+        else
+          each_values = [ value ]
+          each_values_set = [ options.fetch(:value_set, true) ]
+          each_sources = [ source ]
+        end
+
+        each_location = each ? location.relative(each[:options][:as] || each[:target]) : location
+
+        each_values.each.with_index do |each_value,i|
+
+          each_index_location = each ? each_location.relative(i) : location
+          context_proxy.current_location = each_index_location
+
+          next if validation_definition[:conditions].any?{ |condition| !condition.fulfilled?(each_value, context_proxy) }
+
+          validation_definition[:validations].each do |validation|
+
+            next if validation[:conditions] && validation[:conditions].any?{ |condition| !condition.fulfilled?(each_value, context_proxy) }
+
+            validation_definition[:targets].each do |target|
+
+              target_value_info = extract each_value, target, value_set: each_values_set[i], source: source
+
+              validation_location = target ? each_index_location.relative(validation[:target_alias] || target) : each_index_location
+              context_proxy.current_location = validation_location
+
+              error_options = {
+                value: target_value_info[:value],
+                source: target_value_info[:source],
+                value_set: target_value_info[:value_set],
+                constraints: validation[:validation_options]
+              }
+
+              error_options[:location] = validation_location unless validation_location.kind_of? Errapi::Locations::None
+
+              error_options[:validation] = validation[:validation_name] if validation[:validation_name]
+
+              context_proxy.with_error_options error_options do
+                validation_options = { location: validation_location, value_set: target_value_info[:value_set] }
+                validation[:validation].validate target_value_info[:value], context_proxy, validation_options
+              end
+            end
+          end
+        end
+      end
+
+      # TODO: add config option to raise error by default
+      raise Errapi::ValidationFailed.new(context) if options[:raise_error] && context.errors?
+
+      context_proxy.valid?
+    end
+
+    def relative_location location
+      RelativeLocation.new location
+    end
+
+    private
+
+    class RelativeLocation
+      attr_reader :location
+
+      def initialize location
+        @location = location
+      end
+    end
+
+    def extract value, target, options = {}
+
+      source = options[:source]
+      value_set = options.fetch :value_set, true
+
+      if target.nil?
+        { value: value, value_set: value_set, source: source }
+      elsif target.respond_to? :call
+        { value: target.call(value), value_set: value_set, source: value }
+      elsif value.kind_of? Hash
+        { value: value[target], value_set: value.key?(target), source: value }
+      elsif value.respond_to?(target)
+        { value: value.send(target), value_set: value_set, source: value }
+      else
+        { value_set: false, source: value }
+      end
+    end
+
+    def register_validations *args, &block
+      # TODO: allow to set custom error options (e.g. reason) when registering validation
+
+      options = args.last.kind_of?(Hash) ? args.pop : {}
+      target_alias = options.delete :as
+
+      validations_definition = {
+        validations: []
+      }
+
+      # FIXME: register all validations (from :with, from block and from hash) in the order they are given
+      if options[:with]
+        validations_definition[:validations] += [*options.delete(:with)].collect{ |with| { validation: with, validation_options: {}, target_alias: target_alias } }
+      end
+
+      if block
+        validations_definition[:validations] << { validation: self.class.new(@config, &block), validation_options: {}, target_alias: target_alias }
+      end
+
+      if options[:each]
+        validations_definition[:each] = {
+          target: options.delete(:each),
+          options: options.delete(:each_options)
+        }
+      end
+
+      validations_definition[:conditions] = @config.extract_conditions! options
+
+      validations = options
+      raise Errapi::ValidationDefinitionInvalid, "No validation was defined. Use registered validations (e.g. `presence: true`), the :with option, or a block to define validations." if validations_definition[:validations].empty? && validations.empty?
+
+      validations.each do |validation_name,options|
+        next unless options
+        validation_options = options.kind_of?(Hash) ? options : {}
+        validation_target_alias = validation_options.delete(:as) || target_alias
+        conditions = @config.extract_conditions! validation_options
+        validation = @config.validation validation_name, validation_options
+        validations_definition[:validations] << { validation: validation, validation_name: validation_name, validation_options: validation_options, target_alias: validation_target_alias, conditions: conditions }
+      end
+
+      validations_definition[:targets] = args.empty? ? [ nil ] : args
+
+      @validations << validations_definition
+    end
+
+    class ContextProxy
+      instance_methods.each{ |m| undef_method m unless m =~ /(^__|^send$|^object_id$)/ }
+      attr_accessor :current_location
+
+      def initialize context, validator, location
+        @context = context
+        @validator = validator
+        @current_location = location
+        @error_options = {}
+      end
+
+      def add_error options = {}, &block
+        @context.add_error @error_options.merge(options), &block
+      end
+
+      def errors? criteria = {}, &block
+
+        if criteria[:location].kind_of? RelativeLocation
+          criteria = criteria.dup
+          criteria[:location] = @current_location.relative criteria[:location].location
+        end
+
+        @context.errors? criteria, &block
+      end
+
+      # TODO: override errors? to support matching relative error locations
+
+      def with_error_options error_options = {}, &block
+        previous_error_options = @error_options
+        @error_options = error_options
+        block.call
+        @error_options = previous_error_options
+      end
+
+      protected
+
+      def method_missing name, *args, &block
+        @context.send name, *args, &block
+      end
+    end
+  end
+end

data/lib/errapi/plugins/i18n_messages.rb

@@ -0,0 +1,20 @@
+require 'i18n'
+
+# TODO: support interpolating source and target name (e.g. "Project name cannot be null.")
+class Errapi::Plugins::I18nMessages
+  class << self
+
+    def serialize_error error, serialized
+      return if serialized.key? :message
+
+      if I18n.exists? translation_key = "errapi.#{error.reason}"
+        interpolation_values = INTERPOLATION_KEYS.inject({}){ |memo,key| memo[key] = error.send(key); memo }.reject{ |k,v| v.nil? }
+        serialized[:message] = I18n.t translation_key, interpolation_values
+      end
+    end
+
+    private
+
+    INTERPOLATION_KEYS = %i(check_value checked_value)
+  end
+end

data/lib/errapi/plugins/location.rb

@@ -0,0 +1,29 @@
+module Errapi
+  class Plugins::Location
+    class << self
+      attr_writer :config
+      attr_accessor :camelize
+
+      def serialize_error error, serialized
+        if error.location && error.location.respond_to?(:serialize)
+
+          serialized_location = error.location.serialize
+          unless serialized_location.nil?
+            serialized[:location] = serialized_location
+            serialized[location_type_key] = error.location.location_type if error.location.respond_to? :location_type
+          end
+        end
+      end
+
+      private
+
+      def location_type_key
+        camelize? ? :locationType : :location_type
+      end
+
+      def camelize?
+        @camelize.nil? ? @config.options.camelize : @camelize
+      end
+    end
+  end
+end

data/lib/errapi/plugins/reason.rb

@@ -0,0 +1,22 @@
+module Errapi
+  class Plugins::Reason
+    class << self
+      attr_writer :config
+      attr_accessor :camelize
+
+      def serialize_error error, serialized
+        serialized[:reason] = serialized_reason error
+      end
+
+      private
+
+      def serialized_reason error
+        camelize? ? Utils.camelize(error.reason.to_s).to_sym : error.reason
+      end
+
+      def camelize?
+        @camelize.nil? ? @config.options.camelize : @camelize
+      end
+    end
+  end
+end

data/lib/errapi/plugins.rb

@@ -0,0 +1,4 @@
+module Errapi::Plugins
+end
+
+Dir[File.join File.dirname(__FILE__), File.basename(__FILE__, '.*'), '*.rb'].each{ |lib| require lib }