dto_schema 0.0.0 → 0.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e5c58baab04f8cdf46c9772682dd02c47de4f6d1ab30d8104d8b19d2978060b6
-  data.tar.gz: acc3fa9351ce74f4eed4667c8baf183e0f0d616ea0152c9ac7d22d4ae9be1c54
+  metadata.gz: b04216668970682a3eaa4bc062784a6d977dbd1e6e795bf30904e28aa48715b8
+  data.tar.gz: 94151a67d6deecf1b3cc0b799b4b0b23efb945c61e4d79d5d84bfe16144dc6c4
 SHA512:
-  metadata.gz: feaf6f8e2f9f78315f67cefb874c5b269989229b4de33bfea5f910b291edaddf37ff6b1a2f91cf0c032087291cbaf2ab1beb469b7ab2c10153f99fd5399b9449
-  data.tar.gz: 9d4296c13f3b8542fa81bddf160906405a2c8e9fa1fc1c2a812656ac685c5cd540d8e1f5c67ddf76109fff0757517028cb4fb8d437f5d159559eac8627fea217
+  metadata.gz: c201e08d594b7b2d6b9caa0fa596101d41e5a40a52bc700e0673fae1f20e8461565ba457ddb4b2b80cd9915127c3cbafbfd828205d94e1bc5db51777dda8dea0
+  data.tar.gz: c7da82328e46a70b91d6ee466c0efd0ae02f52ce8724663fe2ef92010354feb9783f79be68eee3745acfd483d4de3020faed11f24a6bfbf89926263464ec4c49

data/README.md

@@ -1,7 +1,16 @@
 # Ruby DTO-Schema
+[![Gem Version](https://badge.fury.io/rb/dto_schema.svg)](https://badge.fury.io/rb/dto_schema)
+[![Build Status](https://travis-ci.org/stepan-anokhin/dto-schema.svg?branch=master)](https://travis-ci.org/stepan-anokhin/dto-schema)
+[![Coverage Status](https://coveralls.io/repos/github/stepan-anokhin/dto-schema/badge.svg?branch=master)](https://coveralls.io/github/stepan-anokhin/dto-schema?branch=master)
 
 DTO-Schema is a small Ruby library to validate simple data. 
 
+## Installation
+
+```shell script
+gem install dto_schema
+```
+
 ## What is validated?
 
 A notion of `Simple Data` could be defined as follows: 
@@ -18,7 +27,7 @@ Define a schema:
 ```ruby
 require 'dto_schema'
 
-schema = DTO::Schema.new do
+schema = DTOSchema::define do
     object :tag do
         required :name, String, check: [:not_empty]
         required :value, String, check: [:not_empty]

data/lib/dto_schema.rb

@@ -1,5 +1,9 @@
-module DTOSchema
-  class Schema
+require_relative 'dto_schema/schema'
 
+module DTOSchema
+  def self.define(&block)
+    Schema.new(&block)
   end
+
+
 end

data/lib/dto_schema/checks.rb

@@ -0,0 +1,65 @@
+module DTOSchema
+  module Checks
+
+    class Check
+      def initialize (check)
+        @check = check
+      end
+
+      def validate (data, args = nil)
+        result = @check.call(data) if args.nil?
+        result = @check.call(data, args) unless args.nil?
+        return result if result.is_a? Array
+        return [result] if result.is_a? String
+        []
+      end
+
+      def resolve
+        self
+      end
+    end
+
+    class CheckReference
+      def initialize (schema, ref, args = nil)
+        @schema, @ref = schema, ref
+        @args = args
+      end
+
+      def validate (data, args = nil)
+        resolve.validate data, args
+      end
+
+      def resolve
+        @schema.resolve_check @ref
+      end
+    end
+
+    class BoundCheck
+      def initialize (check, args)
+        @check = check
+        @args = args
+      end
+
+      def validate (data, args = {})
+        args = @args.merge(args)
+        @check.validate data, args
+      end
+
+      def resolve
+        @check.resolve
+      end
+    end
+
+    class CheckBinder
+      def initialize (schema)
+        @schema = schema
+      end
+
+      def method_missing (name, args = {})
+        check = CheckReference.new @schema, name
+        BoundCheck.new check, args
+      end
+    end
+
+  end
+end

data/lib/dto_schema/schema.rb

@@ -0,0 +1,82 @@
+require_relative 'checks'
+require_relative 'validators'
+
+module DTOSchema
+  class CheckBinder
+    def initialize (schema)
+      @schema = schema
+    end
+
+    def method_missing (name, args = {})
+      check = Checks::CheckReference.new @schema, name
+      Checks::BoundCheck.new check, args
+    end
+  end
+
+  class Schema
+    def initialize(&block)
+      @validators = {}
+      @checks = {}
+      @check_binder = CheckBinder.new self
+      define(&block)
+    end
+
+    def define (&block)
+      self.instance_eval &block unless block.nil?
+      resolve
+    end
+
+    def object(name, &definition)
+      validator = Validators::ObjectValidator.new self
+      validator.instance_eval(&definition)
+      @validators[name] = validator
+
+      self.define_singleton_method(name) do
+        validator
+      end
+
+      self.define_singleton_method("#{name}?".to_sym) do |data|
+        validator.valid_structure? data
+      end
+
+      self.define_singleton_method("validate_#{name}".to_sym) do |data|
+        validator.validate data
+      end
+
+      self.define_singleton_method("valid_#{name}?".to_sym) do |data|
+        validator.valid? data
+      end
+
+      validator
+    end
+
+    def list
+      Validators::ListValidator.new self, Validators::AnyValidator.new
+    end
+
+    def check(name = nil, &body)
+      return @check_binder if name.nil? && body.nil?
+      raise ArgumentError, "Check definition name is not provided" if name.nil?
+      raise ArgumentError, "Check definition is not provided for `#{name}`" if body.nil?
+      result = Checks::Check.new(body)
+      @checks[name] = result
+      result
+    end
+
+    def resolve
+      @validators.each_value { |validator| validator.resolve }
+      @checks.each_value { |check| check.resolve }
+      self
+    end
+
+    def resolve_validator (name)
+      raise NameError, "Undefined validator `#{name}'" unless @validators.include? name
+      @validators[name]
+    end
+
+    def resolve_check (name)
+      raise NameError, "Undefined check `#{name}'" unless @checks.include? name
+      @checks[name]
+    end
+  end
+end

data/lib/dto_schema/validators.rb

@@ -0,0 +1,260 @@
+require_relative 'checks'
+
+module DTOSchema
+  module Validators
+
+    class BaseValidator
+      def resolve
+        self
+      end
+
+      protected
+
+      def resolve_validator (spec)
+        return PrimitiveValidator.new(spec) if primitive? spec
+        return spec if validator? spec
+        resolve_reference spec if reference? spec
+      end
+
+      def primitive? (spec)
+        spec.is_a?(Class) && (spec <= Numeric || spec <= String)
+      end
+
+      def validator? (spec)
+        spec.is_a? BaseValidator
+      end
+
+      def reference? (spec)
+        spec.is_a? Symbol
+      end
+
+      def resolve_reference (ref)
+        ValidatorReference.new @schema, ref
+      end
+    end
+
+    class BoolValidator < BaseValidator
+      def valid? (data)
+        data.is_a?(TrueClass) || data.is_a?(FalseClass)
+      end
+
+      def validate (data)
+        return ["Must be boolean"] unless valid? data
+        []
+      end
+
+      alias :valid_structure? :valid?
+    end
+
+    class AnyValidator < BaseValidator
+      def valid? (data)
+        true
+      end
+
+      def validate
+        []
+      end
+
+      alias :valid_structure? :valid?
+    end
+
+    class PrimitiveValidator < BaseValidator
+      def initialize (type)
+        @type = type
+      end
+
+      def valid? (data)
+        data.is_a? @type
+      end
+
+      def validate (data)
+        return ["Must be a #{@type}"] unless valid? data
+        []
+      end
+
+      alias :valid_structure? :valid?
+    end
+
+    class ValidatorReference < BaseValidator
+      def initialize (schema, ref)
+        @schema, @ref = schema, ref
+      end
+
+      def valid? (data)
+        resolve.valid? data
+      end
+
+      def validate (data)
+        resolve.validate data
+      end
+
+      def valid_structure? (data)
+        resolve.valid_structure? data
+      end
+
+      def resolve
+        @schema.resolve_validator @ref
+      end
+    end
+
+    class ListValidator < BaseValidator
+      def initialize(schema, item_validator)
+        @schema, @item_validator = schema, item_validator
+      end
+
+      def valid? (data)
+        data.is_a?(Array) && data.all? { |item| @item_validator.valid? item }
+      end
+
+      def validate (data)
+        return ["Must be an array"] unless data.is_a? Array
+        result = {}
+        data.each_with_index do |value, i|
+          errors = @item_validator.validate value
+          result[i] = errors unless errors.empty?
+        end
+        result
+      end
+
+      def valid_structure? (data)
+        data.is_a?(Array) && data.all? { |item| @item_validator.valid_structure? item }
+      end
+
+      def [] (spec)
+        validator = resolve_validator spec
+        ListValidator.new @schema, validator
+      end
+
+      def resolve
+        @item_validator.resolve
+        self
+      end
+    end
+
+    class FieldValidator < BaseValidator
+      def initialize(schema, name, required, type, check)
+        raise ArgumentError, "'#{name}' cannot have checks as it is not a primitive" unless check.empty? || primitive?(type)
+        @schema, @name, @required, @type, @check = schema, name, required, type, check
+        @type_validator = resolve_validator type
+      end
+
+      def validate (data)
+        return ["Cannot be null"] if @required && data.nil?
+        return [] if !@required && data.nil?
+        return @type_validator.validate data unless primitive? @type
+        type_check = @type_validator.validate data
+        return type_check unless type_check.empty?
+        @check.collect { |check| check.validate data }.flatten(1)
+      end
+
+      def valid_structure? (data)
+        return !@required if data.nil?
+        @type_validator.valid_structure? data
+      end
+
+      def valid? (data)
+        validate(data).empty?
+      end
+
+      def resolve
+        @type_validator.resolve
+        @check.each { |check| check.resolve }
+        self
+      end
+    end
+
+    class Invariant
+      def initialize (fields, block)
+        @fields = fields || []
+        @check = Checks::Check.new block
+      end
+
+      def validate (data)
+        errors = @check.validate data
+        return {} if errors.empty?
+        return errors if @fields.empty?
+        result = {}
+        @fields.each { |field| result[field] = errors }
+        result
+      end
+    end
+
+    class ObjectValidator < BaseValidator
+      def initialize (schema)
+        @schema = schema
+        @fields = {}
+        @invariants = []
+      end
+
+      def field (name, required: false, type: AnyValidator.new, check: nil, &validations)
+        check ||= []
+        check = [check] if check.is_a?(Symbol) || check.is_a?(Checks::BoundCheck)
+        check = check.collect { |check_spec| resolve_check check_spec }
+        check.append(Check.new validations) unless validations.nil?
+        @fields[name] = FieldValidator.new @schema, name, required, type, check
+      end
+
+      def required(name, type, check: nil, &validations)
+        field(name, required: true, type: type, check: check, &validations)
+      end
+
+      def optional(name, type, check: nil, &validations)
+        field(name, required: false, type: type, check: check, &validations)
+      end
+
+      def validate (data)
+        return ["Cannot be null"] if data.nil?
+        return ["Must be object"] unless data.is_a? Hash
+        result = {}
+        @fields.each_pair do |name, validator|
+          errors = validator.validate data[name]
+          result[name] = errors unless errors.empty?
+        end
+        return result unless result.empty?
+        @invariants.each do |invariant|
+          errors = invariant.validate data
+          return errors unless errors.empty?
+        end
+        {}
+      end
+
+      def valid? (data)
+        validate(data).empty?
+      end
+
+      def valid_structure? (data)
+        return false unless data.is_a? Hash
+        @fields.all? { |name, validator| validator.valid_structure? data[name] }
+      end
+
+      def list
+        @schema.list
+      end
+
+      def check
+        @schema.check
+      end
+
+      def invariant (fields = nil, &block)
+        fields = [] if fields.nil?
+        fields = [fields] if fields.is_a? Symbol
+        @invariants << Invariant.new(fields, block)
+      end
+
+      def resolve
+        @fields.each_value { |field| field.resolve }
+        self
+      end
+
+      private
+
+      def resolve_check (check)
+        return check if check.is_a? Checks::BoundCheck
+        return Checks::CheckReference.new @schema, check if check.is_a? Symbol
+        raise ArgumentError, "Unexpected check type: #{check.class}"
+      end
+    end
+
+
+  end
+end

data/lib/dto_schema/version.rb

@@ -1,3 +1,3 @@
 module DTOSchema
-  VERSION = "0.0.0"
+  VERSION = "0.0.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dto_schema
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.0.1
 platform: ruby
 authors:
 - Stepan Anokhin
@@ -20,6 +20,9 @@ files:
 - README.md
 - dto_schema.gemspec
 - lib/dto_schema.rb
+- lib/dto_schema/checks.rb
+- lib/dto_schema/schema.rb
+- lib/dto_schema/validators.rb
 - lib/dto_schema/version.rb
 homepage: https://github.com/stepan-anokhin/dto-schema
 licenses: