rasti-form 3.0.0 → 5.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 9dd0424409c0c7232782c40cde8dbf7fa84752d3
-  data.tar.gz: a7c8be9e98dcc9e6d52482469486ba643a0ffa33
+SHA256:
+  metadata.gz: 4c0a64e1d1120b8c55b78a969c8d53f2e01dc152bf7c54da19950024ae593e88
+  data.tar.gz: 3045f978fe98478268719e4d73c76d81b0d4e81ef57cf5559ef9fba6add3b0f7
 SHA512:
-  metadata.gz: a2fb881aec7bca876dd58a3c2bf3e6dcca8ac3f13777437992f4e359d07856c9a7075e4b4c51882f41cb30ffacb8ebf85616632898efbfa02ccd7abea6a7e81c
-  data.tar.gz: c77fed8829801cae565a567f3303b8c4271e5a9b3b79c7ac2f04475e48a9bc6d884e80e2253903a0374a4848d635cf0576a1b191044c850f6cf9aea70a373416
+  metadata.gz: 75b3b3c7a0e7f0293c8d4d1b345700fb44f925e17567f93d1d699579338ea7f61952181c5b18de59b0f17f09c08fca1655120b9c51799a4e6d36d58e213e17b0
+  data.tar.gz: 906759fe1adec8fb89b55ba07e8d37c0e8f2bfbcef9b8eb693b7552a294ffe6eccae1ab840a7286f2b9113397fd89049f7de597a7df70c041685385cc58ddcda

data/.ruby-version

@@ -1 +1 @@
-ruby-2.4.0
+ruby-2.5.7

data/.travis.yml

@@ -1,15 +1,15 @@
 language: ruby
 
 rvm:
-  - 1.9.3
-  - 2.0
   - 2.1
   - 2.2
-  - 2.3.0
-  - 2.4.0
-  - 2.5.0
-  - jruby-1.7.25
-  - jruby-9.1.7.0
+  - 2.3
+  - 2.4
+  - 2.5
+  - 2.6
+  - 2.7
+  - 3.0
+  - jruby-9.2.9.0
   - ruby-head
   - jruby-head
 
@@ -17,7 +17,4 @@ matrix:
   fast_finish: true
   allow_failures:
     - rvm: ruby-head
-    - rvm: jruby-head
-
-before_install:
-  - gem install bundler
+    - rvm: jruby-head

data/README.md

@@ -4,7 +4,6 @@
 [![Build Status](https://travis-ci.org/gabynaiman/rasti-form.svg?branch=master)](https://travis-ci.org/gabynaiman/rasti-form)
 [![Coverage Status](https://coveralls.io/repos/github/gabynaiman/rasti-form/badge.svg?branch=master)](https://coveralls.io/github/gabynaiman/rasti-form?branch=master)
 [![Code Climate](https://codeclimate.com/github/gabynaiman/rasti-form.svg)](https://codeclimate.com/github/gabynaiman/rasti-form)
-[![Dependency Status](https://gemnasium.com/gabynaiman/rasti-form.svg)](https://gemnasium.com/gabynaiman/rasti-form)
 
 Forms validations and type casting
 

data/lib/rasti/form.rb

@@ -1,167 +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
+        cast_attributes!
 
-          def self.inherited(subclass)
-            subclass.instance_variable_set :@attributes, attributes.dup
-          end
+      rescue Rasti::Model::UnexpectedAttributesError => ex
+        ex.attributes.each do |attr_name|
+          errors[attr_name] << 'unexpected attribute'
         end
-      end
-
-      def attribute(name, type, options={})
-        attributes[name.to_sym] = options.merge(type: type)
-        attr_reader name
-      end
-
-      def attributes
-        @attributes ||= {}
-      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}"
-    end
-
-    def write_attribute(name, value)
-      typed_value = value.nil? ? nil : self.class.attributes[name][:type].cast(value)
-      instance_variable_set "@#{name}", typed_value
+    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 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'
-    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,59 +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
-        "Validation error: #{scope} #{JSON.dump(errors)}"
+      private
+
+      def message_title
+        'Validation errors:'
       end
 
     end

data/lib/rasti/form/validable.rb

@@ -17,9 +17,15 @@ module Rasti
       end
 
       def assert(key, condition, message)
-        return true if condition
-        
-        errors[key] << message
+        errors[key] << message unless condition
+        condition
+      end
+
+      def assert_not_error(key)
+        yield
+        true
+      rescue => ex
+        errors[key] << ex.message
         false
       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       = '5.0.0'
   spec.authors       = ['Gabriel Naiman']
   spec.email         = ['gabynaiman@gmail.com']
   spec.summary       = 'Forms validations and type casting'
@@ -19,19 +14,13 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
 
   spec.add_runtime_dependency 'multi_require', '~> 1.0'
+  spec.add_runtime_dependency 'rasti-model', '~> 2.0'
 
-  spec.add_development_dependency 'bundler', '~> 1.12'
-  spec.add_development_dependency 'rake', '~> 11.0'
+  spec.add_development_dependency 'rake', '~> 12.0'
   spec.add_development_dependency 'minitest', '~> 5.0', '< 5.11'
   spec.add_development_dependency 'minitest-colorin', '~> 0.1'
   spec.add_development_dependency 'minitest-line', '~> 0.6'
   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