rasti-form 3.1.2 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d63a6c2410b6e7bbb259a0212442d2aad83fa53c4191856baf04466d3e9c73d0
-  data.tar.gz: 1605263448bb732f3095b5fba45829ece27cecf159c2dbe39d1729dc3dc7981d
+  metadata.gz: f480a81f5d023100e579147654b5026d29f6d00d43099756ec80304e96fbd71d
+  data.tar.gz: 31c790f10607e20335262383955d7919d33aa6f54aa4fe0d7a9caa75c1bc973c
 SHA512:
-  metadata.gz: e5df6a4b5dc7e8b1181a72ef0a1c9ba51b13b643c25c5cb6b8fef47369b181ee0c3598da1d4a22884dee6b5d4b9515f5638a52ae7a15b7cb9dd6c91c92863a76
-  data.tar.gz: da10879fdf48628f72e4d353ee22b628e7520c2e2201918712c63401bb81cd6a1550916f2d1c93bf68249b03ed98c938266842713c32f9bc3d380b7f3e8834fa
+  metadata.gz: 83aaf5a613afd59afc64486b0228226dd9122e2096cdb38f8b8faad6fb07a19c8ac427bc677cc90bb804d63d2a39cef37b05f6215658ea1867d96c8e5ddf50ef
+  data.tar.gz: 55ba10cfb9a398999f928c5a803ad751c32989416c1bc2a164f105d436a46fe63ff75a47893e29436ec8cf85b93a51b49f09aa94e2a6ac8481ce6b628c39e4ab

data/lib/rasti/form.rb

@@ -1,171 +1,72 @@
-require 'json'
+require 'rasti-model'
 require 'multi_require'
 
 module Rasti
-  class Form
+  class Form < Rasti::Model
 
     extend MultiRequire
 
     require_relative_pattern 'form/*'
-    require_relative_pattern 'form/types/*'
 
     include Validable
 
-    class << self
+    def initialize(attributes={})
+      begin
+        super attributes
 
-      def [](attributes)
-        Class.new(self) do
-          attributes.each do |name, type, options={}|
-            attribute name, type, options
-          end
-        end
-      end
-
-      def inherited(subclass)
-        subclass.instance_variable_set :@attributes, attributes.dup
-      end
-
-      def attribute(name, type, options={})
-        attributes[name.to_sym] = options.merge(type: type)
-        attr_reader name
-      end
+        cast_attributes!
 
-      def attributes
-        @attributes ||= {}
-      end
+      rescue Rasti::Model::UnexpectedAttributesError => ex
+        ex.attributes.each do |attr_name|
+          errors[attr_name] << 'unexpected attribute'
+        end
 
-      def attribute_names
-        attributes.keys
-      end
+      rescue Rasti::Types::CompoundError => ex
+        ex.errors.each do |key, messages|
+          errors[key] += messages
+        end
 
-      def to_s
-        "#{name || self.superclass.name}[#{attribute_names.map(&:inspect).join(', ')}]"
       end
-      alias_method :inspect, :to_s
 
-    end
-
-    def initialize(attrs={})
-      assign_attributes attrs
-      set_defaults
       validate!
     end
 
-    def to_s
-      "#<#{self.class.name || self.class.superclass.name}[#{to_h.map { |n,v| "#{n}: #{v.inspect}" }.join(', ')}]>"
-    end
-    alias_method :inspect, :to_s
-
-    def attributes(options={})
-      attributes_filter = {only: assigned_attribute_names, except: []}.merge(options)
-      (attributes_filter[:only] - attributes_filter[:except]).each_with_object({}) do |name, hash|
-        hash[name] = serialize(read_attribute(name))
-      end
-    end
-    
-    def to_h
-      attributes
-    end
-
-    def assigned?(name)
-      assigned_attribute_names.include? name
-    end
-
-    def ==(other)
-      other.kind_of?(self.class) && other.attributes == attributes
-    end
-
-    def eql?(other)
-      other.instance_of?(self.class) && other.attributes == attributes
-    end
-
-    def hash
-      [self.class, attributes].hash
+    def assigned?(attr_name)
+      assigned_attribute? attr_name.to_sym
     end
 
     private
 
-    def assign_attributes(attrs={})
-      attrs.each do |name, value|
-        attr_name = name.to_sym
-        begin
-          if self.class.attributes.key? attr_name
-            write_attribute attr_name, value
-          else
-            errors[attr_name] << 'unexpected attribute'
-          end
-        
-        rescue CastError => error
-          errors[attr_name] << error.message
-        
-        rescue MultiCastError, ValidationError => error
-          error.errors.each do |inner_name, inner_errors| 
-            inner_errors.each { |message| errors["#{attr_name}.#{inner_name}"] << message }
-          end
-        end        
-      end
-    end
-
-    def set_defaults
-      (self.class.attribute_names - attributes.keys).each do |name|
-        if self.class.attributes[name].key? :default
-          value = self.class.attributes[name][:default]
-          write_attribute name, value.is_a?(Proc) ? value.call(self) : value
-        end
-      end
-    end
-
-    def assigned_attribute_names
-      self.class.attribute_names & instance_variables.map { |v| v.to_s[1..-1].to_sym }
-    end
-
-    def serialize(value)
-      if value.kind_of? Array
-        value.map { |v| serialize v }
-      elsif value.kind_of? Form
-        value.attributes
-      else
-        value
+    def assert_present(attr_name)
+      if !errors.key?(attr_name)
+        assert attr_name, assigned?(attr_name) && !public_send(attr_name).nil?, 'not present'
       end
+    rescue Types::Error
+      assert attr_name, false, 'not present'
     end
 
-    def read_attribute(name)
-      instance_variable_get "@#{name}"
+    def assert_not_present(attr_name)
+      assert attr_name, !assigned?(attr_name) || public_send(attr_name).nil?, 'is present'
+    rescue Types::Error
+      assert attr_name, false, 'is present'
     end
 
-    def write_attribute(name, value)
-      typed_value = value.nil? ? nil : self.class.attributes[name][:type].cast(value)
-      instance_variable_set "@#{name}", typed_value
-    end
-
-    def fetch(attribute)
-      attribute.to_s.split('.').inject(self) do |target, attr_name|
-        target.nil? ? nil : target.public_send(attr_name)
+    def assert_not_empty(attr_name)
+      if assert_present attr_name
+        value = public_send attr_name
+        assert attr_name, value.is_a?(String) ? !value.strip.empty? : !value.empty?, 'is empty'
       end
     end
 
-    def assert_present(attribute)
-      assert attribute, !fetch(attribute).nil?, 'not present' unless errors.key? attribute
-    end
-
-    def assert_not_present(attribute)
-      assert attribute, fetch(attribute).nil?, 'is present'
-    end
-
-    def assert_not_empty(attribute)
-      if assert_present attribute
-        value = fetch attribute
-        assert attribute, value.is_a?(String) ? !value.strip.empty? : !value.empty?, 'is empty'
+    def assert_included_in(attr_name, set)
+      if assert_present attr_name
+        assert attr_name, set.include?(public_send(attr_name)), "not included in #{set.map(&:inspect).join(', ')}"
       end
     end
 
-    def assert_time_range(attribute_from, attribute_to)
-       assert attribute_from, public_send(attribute_from) <= public_send(attribute_to), 'invalid time range'
-    end
-
-    def assert_included_in(attribute, set)
-      if assert_present attribute
-        assert attribute, set.include?(fetch(attribute)), "not included in #{set.map { |e| e.is_a?(::String) ? "'#{e}'" : e.inspect }.join(', ')}"
+    def assert_range(attr_name_from, attr_name_to)
+      if assert_present(attr_name_from) && assert_present(attr_name_to)
+        assert attr_name_from, public_send(attr_name_from) <= public_send(attr_name_to), 'invalid range'
       end
     end
 

data/lib/rasti/form/errors.rb

@@ -1,65 +1,19 @@
 module Rasti
   class Form
-    
-    class CastError < StandardError
 
-      attr_reader :type, :value
+    class ValidationError < Rasti::Types::CompoundError
 
-      def initialize(type, value)
-        @type = type
-        @value = value
-      end
-
-      def message
-        "Invalid cast: #{display_value} -> #{type}"
-      end
-
-      private
-
-      def display_value
-        value.is_a?(::String) ? "'#{value}'" : value.inspect
-      end
-
-    end
-
-
-    class MultiCastError < StandardError
+      attr_reader :scope
 
-      attr_reader :type, :value, :errors
-      
-      def initialize(type, value, errors)
-        @type = type
-        @value = value
-        @errors = errors
-      end
-
-      def message
-        "Invalid cast: #{display_value} -> #{type} - #{JSON.dump(errors)}"
-      end
-
-      def display_value
-        value.is_a?(::String) ? "'#{value}'" : value.inspect
-      end
-
-    end
-
-    class ValidationError < StandardError
-
-      attr_reader :scope, :errors
-      
       def initialize(scope, errors)
         @scope = scope
-        @errors = errors
+        super errors
       end
 
-      def message
-        lines = ['Validation errors:']
-
-        errors.each do |key, value|
-          lines << "- #{key}: #{value}"
-        end
+      private
 
-        lines.join("\n")
+      def message_title
+        'Validation errors:'
       end
 
     end

data/lib/rasti/form/validable.rb

@@ -17,17 +17,16 @@ module Rasti
       end
 
       def assert(key, condition, message)
-        return true if condition
-        
-        errors[key] << message
-        false
+        errors[key] << message unless condition
+        condition
       end
 
       def assert_not_error(key)
         yield
         true
-      rescue => error
-        assert key, false, error.message
+      rescue => ex
+        errors[key] << ex.message
+        false
       end
 
     end

data/rasti-form.gemspec

@@ -1,11 +1,6 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'rasti/form/version'
-
 Gem::Specification.new do |spec|
   spec.name          = 'rasti-form'
-  spec.version       = Rasti::Form::VERSION
+  spec.version       = '4.0.0'
   spec.authors       = ['Gabriel Naiman']
   spec.email         = ['gabynaiman@gmail.com']
   spec.summary       = 'Forms validations and type casting'
@@ -19,6 +14,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
 
   spec.add_runtime_dependency 'multi_require', '~> 1.0'
+  spec.add_runtime_dependency 'rasti-model', '~> 1.0'
 
   spec.add_development_dependency 'rake', '~> 12.0'
   spec.add_development_dependency 'minitest', '~> 5.0', '< 5.11'
@@ -27,10 +23,4 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'simplecov', '~> 0.12'
   spec.add_development_dependency 'coveralls', '~> 0.8'
   spec.add_development_dependency 'pry-nav', '~> 0.2'
-
-  if RUBY_VERSION < '2'
-    spec.add_development_dependency 'term-ansicolor', '~> 1.3.0'
-    spec.add_development_dependency 'tins', '~> 1.6.0'
-    spec.add_development_dependency 'json', '~> 1.8'
-  end
 end

data/spec/coverage_helper.rb

@@ -2,6 +2,4 @@ require 'simplecov'
 require 'coveralls'
 
 SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new [SimpleCov::Formatter::HTMLFormatter, Coveralls::SimpleCov::Formatter]
-SimpleCov.start do
-  add_group 'Types', 'lib/rasti/form/types'
-end
+SimpleCov.start

data/spec/minitest_helper.rb

@@ -4,10 +4,4 @@ require 'minitest/colorin'
 require 'pry-nav'
 require 'rasti-form'
 
-module Minitest
-  class Test
-    def as_string(value)
-      value.is_a?(::String) ? "'#{value}'" : value.inspect
-    end
-  end
-end
+T = Rasti::Types

data/spec/validations_spec.rb

@@ -0,0 +1,301 @@
+require 'minitest_helper'
+
+describe Rasti::Form, 'Validations' do
+
+  def build_form(&block)
+    Class.new(Rasti::Form) do
+      class_eval(&block)
+    end
+  end
+
+  def assert_validation_error(expected_errors, &block)
+    error = proc { block.call }.must_raise Rasti::Form::ValidationError
+    error.errors.must_equal expected_errors
+  end
+
+  it 'Validation error message' do
+    scope = Object.new
+    errors = {
+      x: ['not present'],
+      y: ['error 1', 'error 2']
+    }
+
+    error = Rasti::Form::ValidationError.new scope, errors
+
+    error.scope.must_equal scope
+    error.errors.must_equal errors
+    error.message.must_equal "Validation errors:\n- x: [\"not present\"]\n- y: [\"error 1\", \"error 2\"]"
+  end
+
+  it 'Invalid attributes' do
+    assert_validation_error(z: ['unexpected attribute']) do
+      Rasti::Form[:x, :y].new z: 3
+    end
+  end
+
+  it 'Not error' do
+    form = build_form do
+      attribute :text, T::String
+
+      def validate
+        assert_not_error :text do
+          raise 'invalid text' unless assigned? :text
+        end
+      end
+    end
+
+    proc { form.new text: 'text' }.must_be_silent
+
+    assert_validation_error(text: ['invalid text']) do
+      form.new
+    end
+  end
+
+  describe 'Present' do
+
+    let :form do
+      build_form do
+        attribute :number, T::Integer
+
+        def validate
+          assert_present :number
+        end
+      end
+    end
+
+    it 'Success' do
+      proc { form.new number: 1 }.must_be_silent
+    end
+
+    it 'Not assigned' do
+      assert_validation_error(number: ['not present']) do
+        form.new
+      end
+    end
+
+    it 'Nil' do
+      assert_validation_error(number: ['not present']) do
+        form.new number: nil
+      end
+    end
+
+    it 'Invalid cast' do
+      assert_validation_error(number: ['Invalid cast: true -> Rasti::Types::Integer']) do
+        form.new number: true
+      end
+    end
+
+    it 'Invalid nested cast' do
+      range = build_form do
+        attribute :min, T::Integer
+        attribute :max, T::Integer
+
+        def validate
+          assert_range :min, :max
+        end
+      end
+
+      form = build_form do
+        attribute :range, T::Model[range]
+
+        def validate
+          assert_present :range
+        end
+      end
+
+      assert_validation_error('range.max' => ['not present'], range: ['not present']) do
+        form.new range: {min: 1}
+      end
+    end
+
+    it 'With default' do
+      form = build_form do
+        attribute :number, T::Integer, default: 1
+
+        def validate
+          assert_present :number
+        end
+      end
+
+      proc { form.new }.must_be_silent
+
+      assert_validation_error(number: ['not present']) do
+        form.new number: nil
+      end
+    end
+
+  end
+
+  describe 'Not present' do
+
+    let :form do
+      range = build_form do
+        attribute :min, T::Integer
+        attribute :max, T::Integer
+
+        def validate
+          assert_range :min, :max
+        end
+      end
+
+      build_form do
+        attribute :range, T::Model[range]
+
+        def validate
+          assert_not_present :range
+        end
+      end
+    end
+
+    it 'Success not assigned' do
+      proc { form.new }.must_be_silent
+    end
+
+    it 'Success with nil' do
+      proc { form.new range: nil }.must_be_silent
+    end
+
+    it 'Assigned' do
+      assert_validation_error(range: ['is present']) do
+        form.new range: {min: 1, max: 2}
+      end
+    end
+
+    it 'Invalid nested cast' do
+      assert_validation_error('range.max' => ['not present'], range: ['is present']) do
+        form.new range: {min: 1}
+      end
+    end
+
+  end
+
+  describe 'Not empty' do
+
+    it 'Must be present' do
+      form = build_form do
+        attribute :text, T::String
+
+        def validate
+          assert_not_empty :text
+        end
+      end
+
+      proc { form.new text: 'text' }.must_be_silent
+
+      assert_validation_error(text: ['not present']) do
+        form.new text: nil
+      end
+
+      assert_validation_error(text: ['not present']) do
+        form.new
+      end
+    end
+
+    it 'String' do
+      form = build_form do
+        attribute :text, T::String
+
+        def validate
+          assert_not_empty :text
+        end
+      end
+
+      proc { form.new text: 'text' }.must_be_silent
+
+      assert_validation_error(text: ['is empty']) do
+        form.new text: ' '
+      end
+    end
+
+    it 'Array' do
+      form = build_form do
+        attribute :array, T::Array[T::String]
+
+        def validate
+          assert_not_empty :array
+        end
+      end
+
+      proc { form.new array: ['text'] }.must_be_silent
+
+      assert_validation_error(array: ['is empty']) do
+        form.new array: []
+      end
+    end
+
+    it 'Hash' do
+      form = build_form do
+        attribute :hash, T::Hash[T::String, T::String]
+
+        def validate
+          assert_not_empty :hash
+        end
+      end
+
+      proc { form.new hash: {key: 'value'} }.must_be_silent
+
+      assert_validation_error(hash: ['is empty']) do
+        form.new hash: {}
+      end
+    end
+
+  end
+
+  it 'Included in values list' do
+    form = build_form do
+      attribute :text, T::String
+
+      def validate
+        assert_included_in :text, %w(value_1 value_2)
+      end
+    end
+
+    proc { form.new text: 'value_1' }.must_be_silent
+
+    assert_validation_error(text: ['not included in "value_1", "value_2"']) do
+      form.new text: 'xyz'
+    end
+  end
+
+  it 'Time range' do
+    form = build_form do
+      attribute :from, T::Time['%Y-%m-%d %H:%M:%S']
+      attribute :to,   T::Time['%Y-%m-%d %H:%M:%S']
+
+      def validate
+        assert_range :from, :to
+      end
+    end
+
+    from = '2018-01-01 03:10:00'
+    to = '2018-01-01 15:30:00'
+
+    proc { form.new from: from, to: to }.must_be_silent
+
+    assert_validation_error(from: ['invalid range']) do
+      form.new from: to, to: from
+    end
+  end
+
+  it 'Nested validation' do
+    range = build_form do
+      attribute :min, T::Integer
+      attribute :max, T::Integer
+
+      def validate
+        assert_range :min, :max
+      end
+    end
+
+    form = build_form do
+      attribute :range, T::Model[range]
+    end
+
+    proc { form.new range: {min: 1, max: 2} }.must_be_silent
+
+    assert_validation_error('range.min' => ['invalid range']) do
+      form.new range: {min: 2, max: 1}
+    end
+  end
+
+end