rov 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+--- 
+SHA512: 
+  data.tar.gz: 5c17f73e68aca3537540c8ab0c7d75beebeff0150041b96c2e8a70741614d30d22fde5135ea86a0ff4b005f674074c72d40443090560538170db29c951d83f80
+  metadata.gz: 8285b132b2ed8e9f35ca24d9a919889ab94bf288f54834bd83642e5a266cddf4ff42d1dadf6139943d2a35edd8b8c4bfc12ed44fe1bafcfcf6b0f9cc9a4c1021
+SHA1: 
+  data.tar.gz: 909b6429fbdc9baf33b949866a8008a425fa6a7e
+  metadata.gz: 7ad2c1c95ab319ac10e0e85c5f779bcc89b2adf9

data/README.md

@@ -0,0 +1,217 @@
+Robject-Validator
+=================
+
+## Description
+Robject-Validator(Rov) is a object validator for Ruby. Usually there are many
+different data objetcts in your system, and you have to ensure the
+accuracy of the data objects. It's terrible to write validation code for
+each object. It will confuse your system and has high risk for bug.
+
+Rov provides a general mechanism to validate all data objects. All you need is
+defining template for each object, and then Rov will validate them.
+
+
+## Requires
+Rov has no dependencies, unless your objects need other gem packages.
+
+However, your Ruby version can not be less than 1.8.7.
+
+## Install
+From rubygems.org:
+
+    $ gem install rov
+
+Or install Rov from the git repo:
+
+    $ gem build rov.gemspec
+    $ gem install rov-{version}.gem
+
+## Basic usage
+First all, you need to define a template for object. The template is a class
+inherited from `Rov::Template`, and your object is defined in the instance variable
+`@template` of the template class.
+
+For example, a hash object that contains several properties, name, sex, age, email:
+
+```ruby
+  class Person < Rov::Template
+    @template = {
+      :name => kind_of(String),
+      :age => kind_of(Fixnum),
+      :sex => any_of([:male, :female]),
+      :email => kind_of(String),
+    }
+  end
+```
+
+`kind_of` and `any_of` are class methods of Rov::Template.
+
+`kind_of()` takes one argument which is a class. It means the data must be a object
+of String(or its child class).
+
+`any_of()` aslo takes one argument which is an array. It means the data must be a
+element of the array. The element of the array can be any type, symbol, string,
+class, or event a template class(yes, templates can be nested with each other).
+
+After defined, Rov could validate the specific data. Suppose the specific data
+`data`:
+
+```ruby
+  data = {
+    :name => "Scarlet",
+    :age => 30,
+    :sex => :female,
+    :email => "scarlet@email.com",
+  }
+  validator = Rov::Validate.new(Person)
+  status, error_msg = validator.do_validate(data)
+  end
+```
+
+`do_validate` method return two value: the first is the result if validated or not, and
+the second one is error massage if validation fails.
+
+## Advanced Usage
+
+### Required Keys
+If your hash object must contain several specified keys, you can use instance variable
+`@required`. `@required` must be given an array, element in which must present in
+specific data, or validation will fail. By default, `@required` is an empty array. that
+is, the specific data can an empty hash.
+
+For Example:
+
+```ruby
+  class Person < Rov::Template
+    @template = {
+      :name => kind_of(String),
+      :age => kind_of(Fixnum),
+      :sex => any_of([:male, :female]),
+      :email => kind_of(String),
+    }
+    @required = [:name, :age]
+  end
+```
+
+As definition, the specific `Person` data must contain `:name` and `:age`.
+
+
+### Ordered Array
+If the template is given an array, then the specific data must be included in the array.
+By default, there is no restriction on the order of the elements. But you can want to
+do it, there is a instance variable `@ordered`. If `@ordered` will be set `true`, Rov
+will validate the specific array with the order which defined in template.
+
+
+### List of Template Methods
+There are five available template methods:
+
++ `any_of()`
+
+As you known, `any_of()` means the specific data should be included in the given
+array. `any_of()` can be used anywhere, such as hash's key:
+
+```ruby
+  class People < Rov::Template
+    @template = {
+      any_of(names) => Person,
+    }
+  end
+```
+
+Suppose the argument of `any_of()` `names` is an array which contains many names.
+
+Besides, this example shows how to nested template in other template.
+
++ `kind_of()`
+
++ `instance_of()`
+
+The difference with `kind_of()` is that `instance_of()` can not be an instance of
+the class's child class.
+
++ `in_range()`
+
+This method takes an object of `Range`, and the specific data should be included
+in it.
+
++ `anything()`
+
+This function does not accept any arguments. Any specific data will be validated
+if the template data is defined with `anything()`.
+
+
+### Custom Template Method
+You can define new template method. Template method should return a class inherited
+from Rov::Template, like defining template class. In the class, two things must be
+presented, `@template` and `validate_method()`.
+
+`@template` is same as `@template` in the template class. And `validate_method()`
+returns a method by which Rov validates the specific data.
+
+For example, it defines a method `email()` to validate specific data must be a
+email address.
+
+```ruby
+  def email()
+    email_cls = Class.new(Rov::Template) do
+      # @template =
+      def validate_method
+        m = lambda do |actual_value|
+          if actual_value.is_a?(String) and
+              (actual_value =~ /^[a-zA-Z0-9_.+\-]+@[a-zA-Z0-9\-]+\.[a-zA-Z0-9\-.]+$/) == 0
+            [true, ""]
+          else
+            raise_validation_error(:invalid_email)
+          end
+        end
+        return m
+      end
+    end
+    return email_cls
+  end
+```
+
+Because the format of email address is unchanged, the template should be a constant(
+the regex), so there is only `validate_method()` in `email()`. The method that returned
+by `validate_method()` return two value(status and an empty string) if validation succeed.
+If validation fails, just call `raise_validation_error()` with a symbol.
+
+
+### Custom Validation Method
+Sometimes, you may have some special requirements. Rov provides you a way to define
+your custom validation method.
+
+```ruby
+  class Person < Rov::Template
+    @template = {
+      # ...
+      :email => kind_of(String),
+      :address => kind_of(String),
+      :zip_code => kind_of(Fixnum),
+    }
+
+    def validate(actual_value)
+      r = [actual_value[:address], actual_value[:zip_code]]
+      return ((not r.any?) or r.all?)
+    end
+  end
+```
+
+You can define `Rov::Template#validate` method to implement your custom method.
+
+`Rov::Template#validate()` takes one argument `actual_value` which is specific
+data. The example above means the keys `:address` and `:zip_code` are either both
+presented, or both not.
+
+
+### Simple Way Defining Template
+Rov provides a simple way to define a templete, if the template is not complicated.
+With `Rov::Template.create_template()`, you don't need to define a class for each
+template.
+
+```ruby
+  person_cls = Rov::Template.create_template({:name => kind_of(String), :age => kind_of(Fixnum)})
+  validator = Rov::Validate.new(person_cls)
+  validator.do_validate(specific_data)
+```

data/lib/rov.rb

@@ -0,0 +1,10 @@
+# -*- coding : utf-8 -*-
+
+module Rov
+end
+
+require 'rov/common'
+require 'rov/raise_error'
+require 'rov/do_validate'
+require 'rov/template'
+require 'rov/validate'

data/lib/rov/common.rb

@@ -0,0 +1,54 @@
+# -*- coding : utf-8 -*-
+
+module Rov
+  module Common
+    def self.template_cls?(template)
+      return (template.class == Class and template.superclass == Template)
+    end
+
+    def self.string_hash_key(hash)
+      r = hash.map do |k, v|
+        if k.is_a?(Symbol)
+          [k.to_s, v]
+        else
+          [k, v]
+        end
+      end
+      return Hash[r]
+    end
+
+    def self.string_array_element(array)
+      r = array.map do |e|
+        if e.is_a?(Symbol)
+          e.to_s
+        else
+          e
+        end
+      end
+      return r
+    end
+
+    def self.with_symbol_access(hash)
+      return HashWithSymbolAccess[hash.entries]
+    end
+
+  end
+end
+
+class HashWithSymbolAccess < Hash
+  def [](key)
+    if self.keys.include?(key)
+      return super(key)
+    elsif key.is_a?(Symbol) and self.keys.include?(key.to_s)
+      return super(key.to_s)
+    end
+  end
+
+  def []=(key, value)
+    if self.keys.include?(key)
+      super(key, value)
+    elsif key.is_a?(Symbol) and self.keys.include?(key.to_s)
+      super(key.to_s, value)
+    end
+  end
+end

data/lib/rov/do_validate.rb

@@ -0,0 +1,89 @@
+# -*- coding : utf-8 -*-
+module Rov
+  class DoValidate
+
+    include RaiseError
+
+    def initialize(template)
+      if Common.template_cls?(template)
+        @template_obj = template.new(self)
+      else
+        @template_obj = Template.new(self)
+        @template_obj.set_template_value(template)
+      end
+
+      @template_value = @template_obj.get_template_value_for_validation
+      @validate_method = @template_obj.validate_method
+
+      if @template_value.class == self.class.superclass
+        clone_self(@template_value)
+      end
+    end
+
+    def clone_self(template_obj)
+      @template_value = template_obj.get_template_value
+      @validate_method = template_obj.get_validate_method
+      @template_obj = template_obj.get_template_obj
+    end
+
+    def get_template_value
+      return @template_value
+    end
+
+    def get_validate_method
+      return @validate_method
+    end
+
+    def get_template_obj
+      return @template_obj
+    end
+
+    def validate(actual_value)
+      set_value_hash({
+                       :actual_value => actual_value,
+                       :template_value => @template_obj.get_template_value,
+                       :template_value_cls => @template_obj.class,
+                     })
+      status, msg = @validate_method[actual_value]
+      if not status
+        raise RaiseError::InvalidConfig, msg
+      else
+        if not custom_validate(actual_value)
+          raise_validation_error(:self_validate_fail)
+        end
+        return true, ""
+      end
+    end
+
+    def do_validate(actual_value)
+      begin
+        status, msg = validate(actual_value)
+      rescue RaiseError::InvalidConfig => ex
+        status = false
+
+        # it can `raise` a array when ruby version less 1.9.3. # or the array will be inspected.
+        # so, pass the message to eval() when it is a string.
+        if ex.message.is_a?(String)
+          msg = eval(ex.message)
+        else
+          msg = ex.message
+        end
+      end
+      return status, msg
+    end
+
+    def custom_validate(actual_value)
+      return get_template_obj.do_custom_validate(actual_value)
+    end
+
+    def get_option
+      return {}
+    end
+
+    def set_value_hash(hash={})
+      @value_hash ||= {}
+      @value_hash.merge!(hash)
+    end
+
+  end
+end

data/lib/rov/raise_error.rb

@@ -0,0 +1,30 @@
+# -*- coding : utf-8 -*-
+module Rov
+  module RaiseError
+    class InvalidConfig < StandardError
+    end
+
+    def raise_validation_error(error_type)
+      raise InvalidConfig, [error_type, get_error_str(error_type)]
+    end
+
+    def get_error_str(error_type)
+      template_value = @value_hash[:template_value]
+      actual_value = @value_hash[:actual_value]
+
+      types = {
+        :not_include => "#{actual_value.inspect} not in `#{template_value.inspect}`",
+        :type_error => "type of `#{actual_value.inspect}`(#{actual_value.class}) should be #{template_value.class}",
+        :invalid_key => "invalid key `#{@value_hash[:actual_hash_key].inspect}` in `#{actual_value.inspect}`",
+        :surplus_element => "surplus element `#{@value_hash[:actual_array_element].inspect}` in `#{actual_value.inspect}`",
+        :invalid_element => "invalid element in `#{actual_value.inspect}`",
+        :not_in_range => "`#{actual_value.inspect}` not in range of `#{template_value}`",
+        :not_eq => "`#{actual_value.inspect}` not equal to `#{template_value}`",
+        :not_required => "no required key: `#{@value_hash[:required_key].inspect}` in `#{actual_value.inspect}`",
+        :self_validate_fail => "`#{@value_hash[:template_value_cls].inspect}` custom validate method failed",
+      }
+      return types[error_type] || "#{error_type}: #{actual_value.inspect}"
+    end
+
+  end
+end

data/lib/rov/template.rb

@@ -0,0 +1,313 @@
+# -*- coding : utf-8 -*-
+module Rov
+  class Template
+    @required = []
+    @ordered = false
+
+    def self.create_template(template_value)
+      template_cls = Class.new(self) do
+        @template = template_value
+      end
+      return template_cls
+    end
+
+    def self.template
+      return @template
+    end
+
+    def self.template=(value)
+      @template = value
+    end
+
+    def self.required
+      return @required.to_a
+    end
+
+    def self.ordered?
+      return @ordered
+    end
+
+    def initialize(validate_obj)
+      @validate_obj = validate_obj
+      @raw_template_value = self.class.template
+      @required = self.class.required
+    end
+
+    def get_validate_option
+      return @validate_obj.get_option()
+    end
+
+    def set_template_value(value)
+      @raw_template_value = value
+    end
+
+    def get_template_value
+      if @template_value
+        return @template_value
+      end
+      value = @raw_template_value
+      validate_option = get_validate_option()
+
+      if validate_option[:json]
+        if value.is_a?(Hash)
+          value = Common.string_hash_key(value)
+          value = Common.with_symbol_access(value)
+        elsif value.is_a?(Array)
+          value = Common.string_array_element(value)
+        elsif value.is_a?(Symbol)
+          value = value.to_s
+        elsif value == Symbol
+          value = String
+        end
+      end
+
+      @template_value = value
+      return @template_value
+    end
+
+    def get_template_value_for_validation
+      if @template_value_for_validation
+        return @template_value_for_validation
+      end
+      value = get_template_value()
+      case
+      when value.is_a?(Hash)
+        value = Hash[
+                     value.map do |k, v|
+                       if Common.template_cls?(k)
+                         k = @validate_obj.class.new(k)
+                       end
+                       [k, @validate_obj.class.new(v)]
+                     end
+                    ]
+      when value.is_a?(Array)
+        value = value.map {|a| @validate_obj.class.new(a)}
+      # else
+      #   if value.class == @validate_obj.class.superclass
+      #     # clone_self(value)
+      #     value = value
+      #   else
+      #     # @template_value = value
+      #     value = value
+      #   end
+      end
+      @template_value_for_validation = value
+      return @template_value_for_validation
+    end
+
+    def validate_method
+      value = get_template_value_for_validation
+      case
+      when value.is_a?(Hash)
+        m = method(:validate_hash)
+      when value.is_a?(Array)
+        m = method(:validate_array)
+      else
+        if value.is_a?(Class) and value.superclass == self.class.superclass
+          m = value.new(@validate_obj).validate_method
+        else
+          m = method(:validate_other)
+        end
+      end
+
+      return m
+    end
+
+    def validate_required(array)
+      self.required.each do |key|
+        if not @validate_obj.class.new(array).do_validate([key])[0]
+          @validate_obj.set_value_hash(:required_key => key)
+          @validate_obj.raise_validation_error(:not_required)
+        end
+      end
+    end
+
+    def validate_hash(actual_hash)
+      _template_value = get_template_value_for_validation
+      if actual_hash.class != _template_value.class
+        @validate_obj.raise_validation_error(:type_error)
+      end
+      actual_hash.each_pair do |k, v|
+        @validate_obj.set_value_hash(:actual_hash_key => k)
+        if _template_value.keys.include?(k)
+          _template_value[k].validate(v)
+        else
+          is_exist = false
+          (_template_value.keys.find_all {|p| p.class == @validate_obj.class.superclass or p.class == @validate_obj.class}).each do |d|
+            if d.do_validate(k)[0]
+              _template_value[d].validate(v)
+              is_exist = true
+            end
+          end
+          if not is_exist
+            @validate_obj.raise_validation_error(:invalid_key)
+          end
+        end
+      end
+
+      self.validate_required(actual_hash.keys)
+
+      return [true, ""]
+    end
+
+    def validate_array(actual_array)
+      _template_value = get_template_value_for_validation
+      if actual_array.class != _template_value.class
+        @validate_obj.raise_validation_error(:type_error)
+      end
+
+      if self.ordered?
+        actual_array.zip(_template_value).each do |real_element, template_element|
+          if template_element.nil?
+            @validate_obj.set_value_hash(:actual_array_element => real_element)
+            @validate_obj.raise_validation_error(:surplus_element)
+          end
+          template_element.validate(real_element)
+        end
+      else
+        actual_array.each do |re|
+          if _template_value.map {|te| te.do_validate(re)[0]}.none?
+            @validate_obj.raise_validation_error(:invalid_element)
+          end
+        end
+        self.validate_required(actual_array)
+      end
+
+      return [true, ""]
+    end
+
+    def validate_other(actual_value)
+      _template_value = get_template_value_for_validation
+      if not _template_value == actual_value
+        @validate_obj.raise_validation_error(:not_eq)
+      end
+      return [true, ""]
+    end
+
+    def required
+      _required = @required
+      if get_validate_option[:json]
+        case
+        when _required.is_a?(Hash)
+          _required = Common.string_hash_key(_required)
+        when _required.is_a?(Array)
+          _required = Common.string_array_element(_required)
+        when _required.is_a?(Symbol)
+          _required = _required.to_s
+        end
+      end
+      return _required
+    end
+
+    def ordered?
+      return self.class.ordered?
+    end
+
+    def do_custom_validate(actual_value)
+      if get_validate_option[:json]
+        case
+        when actual_value.is_a?(Hash)
+          actual_value = Common.with_symbol_access(actual_value)
+        when actual_value.is_a?(Array)
+          actual_value = Common.string_array_element(actual_value)
+        when actual_value.is_a?(Symbol)
+          actual_value = actual_value.to_s
+        end
+      end
+
+      return self.validate(actual_value)
+    end
+
+    def validate(actual_value)
+      return true
+    end
+
+    def raise_validation_error(error_type)
+      return @validate_obj.raise_validation_error(error_type)
+    end
+
+    # ---------------------------------------------------
+    def self.any_of(lst)
+      any_of_cls = Class.new(Rov::Template) do
+        @template = AnyOfArray.new(lst)
+        def validate_method
+          m = lambda do |actual_value|
+            is_exist = false
+            self.get_template_value_for_validation.each do |_template_value|
+              if _template_value.do_validate(actual_value)[0]
+                is_exist = true
+                break
+              end
+            end
+            if not is_exist
+              @validate_obj.raise_validation_error(:not_include)
+            end
+            [true, ""]
+          end
+          return m
+        end
+      end
+      return any_of_cls
+    end
+
+    def self.instance_of(cls)
+      instance_of_cls = Class.new(Rov::Template) do
+        @template = cls
+
+        def validate_method
+          m = lambda do |actual_value|
+            if not actual_value.instance_of?(self.get_template_value)
+              @validate_obj.raise_validation_error(:type_error)
+            end
+            [true, ""]
+          end
+          return m
+        end
+      end
+      return instance_of_cls
+    end
+
+    def self.kind_of(cls)
+      kind_of_cls = Class.new(Rov::Template) do
+        @template = cls
+
+        def validate_method
+          m = lambda do |actual_value|
+            if not actual_value.is_a?(self.get_template_value)
+              @validate_obj.raise_validation_error(:type_error)
+            end
+            [true, ""]
+          end
+          return m
+        end
+      end
+      return kind_of_cls
+    end
+
+    def self.in_range(_range)
+      in_range_cls = Class.new(Rov::Template) do
+        @template = _range
+
+        def validate_method
+          m = lambda do |actual_value|
+            if not self.get_template_value.include?(actual_value)
+              @validate_obj.raise_validation_error(:not_in_range)
+            end
+            [true, ""]
+          end
+          return m
+        end
+      end
+      return in_range_cls
+    end
+
+    def self.anything
+      return kind_of(Object)
+    end
+
+    # ---------------------------------------------------
+  end
+end
+
+class AnyOfArray < Array
+end

data/lib/rov/validate.rb

@@ -0,0 +1,30 @@
+# -*- coding : utf-8 -*-
+module Rov
+  class Validate
+    def self.validate(template, actual_value, option={})
+      v = self.new(template)
+      return v.do_validate(actual_value, option)
+    end
+
+    def initialize(template)
+      @template = template
+    end
+
+    def do_validate(actual_value, option={})
+      validate_cls = Class.new(DoValidate) do
+        @option = option
+
+        def self.get_option
+          return @option
+        end
+
+        def get_option
+          return self.class.get_option
+        end
+      end
+
+      validate_obj = validate_cls.new(@template)
+      validate_obj.do_validate(actual_value)
+    end
+  end
+end

data/lib/rov/version.rb

@@ -0,0 +1,3 @@
+module Rov
+  VERSION = '0.0.1'
+end

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification 
+name: rov
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Handsome Cheung
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2014-11-01 00:00:00 Z
+dependencies: []
+
+description: rov provides a general mechanism to validate all objects. All you need is defining template for each object, and then rov will validate them.
+email: 
+- handsomecheung@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.md
+- lib/rov.rb
+- lib/rov/common.rb
+- lib/rov/do_validate.rb
+- lib/rov/raise_error.rb
+- lib/rov/template.rb
+- lib/rov/validate.rb
+- lib/rov/version.rb
+homepage: https://github.com/handsomecheung/Robject-Validator
+licenses: 
+- GPL-3.0
+metadata: {}
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.8.7
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 2.4.2
+signing_key: 
+specification_version: 4
+summary: rov(Robject Validator) is a object validator for Ruby
+test_files: []
+