rasti-form 3.1.2 → 6.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d63a6c2410b6e7bbb259a0212442d2aad83fa53c4191856baf04466d3e9c73d0
-  data.tar.gz: 1605263448bb732f3095b5fba45829ece27cecf159c2dbe39d1729dc3dc7981d
+  metadata.gz: efb9cfdea85fcce07f977a6bf54a183aface5cce17bfa3f9720f0b60684f48c3
+  data.tar.gz: f1aa1973dad9c2f363bd8f9f030ca48fd158a9897821439ab9e0d93c334a79de
 SHA512:
-  metadata.gz: e5df6a4b5dc7e8b1181a72ef0a1c9ba51b13b643c25c5cb6b8fef47369b181ee0c3598da1d4a22884dee6b5d4b9515f5638a52ae7a15b7cb9dd6c91c92863a76
-  data.tar.gz: da10879fdf48628f72e4d353ee22b628e7520c2e2201918712c63401bb81cd6a1550916f2d1c93bf68249b03ed98c938266842713c32f9bc3d380b7f3e8834fa
+  metadata.gz: 38d34d94241efe87628538d8f6e59baf91e4f46ecf4afe72aebaddf69136de15e2cde9713329cb20d3fb80d8bbb9cbcb52c9041972f949051b925b89b3ce42fb
+  data.tar.gz: cd250e2f305c5836e6b70b6d1e3d0a0d964311af5ac68d5b033461d74b9461d8a4b1cc1948cc6c7d3e7b1bd399a980d5c84765aeced72cadee7d51408dc35d45

data/.github/workflows/ci.yml

@@ -0,0 +1,36 @@
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+# This workflow will download a prebuilt Ruby version, install dependencies and run tests with Rake
+# For more information see: https://github.com/marketplace/actions/setup-ruby-jruby-and-truffleruby
+
+name: CI
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+
+    runs-on: ubuntu-latest
+    name: Tests
+    strategy:
+      matrix:
+        ruby-version: ['2.1', '2.2', '2.3', '2.4', '2.5', '2.6', '2.7', '3.0', 'jruby-9.2.9.0']
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby-version }}
+        bundler-cache: true # runs 'bundle install' and caches installed gems automatically
+    - name: Run tests
+      run: bundle exec rake

data/README.md

@@ -1,11 +1,11 @@
 # Rasti::Form
 
 [![Gem Version](https://badge.fury.io/rb/rasti-form.svg)](https://rubygems.org/gems/rasti-form)
-[![Build Status](https://travis-ci.org/gabynaiman/rasti-form.svg?branch=master)](https://travis-ci.org/gabynaiman/rasti-form)
+[![CI](https://github.com/gabynaiman/rasti-form/actions/workflows/ci.yml/badge.svg)](https://github.com/gabynaiman/rasti-form/actions/workflows/ci.yml)
 [![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)
 
-Forms validations and type casting
+Forms validations
 
 ## Installation
 
@@ -25,37 +25,18 @@ Or install it yourself as:
 
 ## Usage
 
-```ruby
-T = Rasti::Form::Types
-```
-
-### Type casting
-
-```ruby
-T::Integer.cast '10'   # => 10
-T::Integer.cast '10.5' # => 10
-T::Integer.cast 'text' # => Rasti::Types::CastError: Invalid cast: 'text' -> Rasti::Types::Integer
-
-T::Boolean.cast 'true'  # => true
-T::Boolean.cast 'FALSE' # => false
-T::Boolean.cast 'text'  # => Rasti::Types::CastError: Invalid cast: 'text' -> Rasti::Types::Boolean
-
-T::Time['%Y-%m-%d'].cast '2016-10-22' # => 2016-10-22 00:00:00 -0300
-T::Time['%Y-%m-%d'].cast '2016-10'    # => Rasti::Types::CastError: Invalid cast: '2016-10' -> Rasti::Types::Time['%Y-%m-%d']
-
-T::Array[T::Symbol].cast [1, 'test', :sym] # => [:"1", :test, :sym]
-```
-
 ### Form type coercion
 
 ```ruby
+T = Rasti::Types
+
 PointForm = Rasti::Form[x: T::Integer, y: T::Integer] # => PointForm[:x, :y]
 form = PointForm.new x: '1', y: 2 # => #<PointForm[x: 1, y: 2]>
 form.x # => 1
 form.y # => 2
-form.attributes # => {x: 1, y: 2}
+form.to_h # => {x: 1, y: 2}
 
-PointForm.new x: true # => Validation error: {"x":["Invalid cast: true -> Rasti::Form::Types::Integer"]}
+PointForm.new x: true # => Validation error: {"x":["Invalid cast: true -> Rasti::Types::Integer"]}
 ```
 
 ### Form validations
@@ -84,42 +65,6 @@ form.from # => 2016-10-20 00:00:00 -0300
 form.to   # => 2016-10-28 00:00:00 -0300
 ```
 
-### Built-in types
-
-- Array
-- Boolean
-- Enum
-- Float
-- Form
-- Hash
-- Integer
-- IO
-- Regexp
-- String
-- Symbol
-- Time
-- UUID
-
-### Plugable types
-
-```ruby
-class CustomType
-  class << self
-    extend Castable
-
-    private
-
-    def valid?(value)
-      valid.is_a?(String)
-    end
-
-    def transform(value)
-      value.upcase
-    end
-  end
-end
-```
-
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/gabynaiman/rasti-form.

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

@@ -10,24 +10,27 @@ module Rasti
 
       def validate!
         validate
-        raise ValidationError.new(self, errors) unless errors.empty?
+        raise_if_errors!
       end
 
       def validate
       end
 
+      def raise_if_errors!
+        raise ValidationError.new(self, errors) unless errors.empty?
+      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/lib/rasti/form.rb

@@ -1,171 +1,80 @@
-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
+    alias_method :__initialize__, :initialize
+    private :__initialize__
 
-      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
-
-      def attributes
-        @attributes ||= {}
-      end
-
-      def attribute_names
-        attributes.keys
-      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
+    def initialize(attributes={})
+      assign_attributes! attributes
+      validate_type_casting!
       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 assign_attributes!(attributes)
+      __initialize__ attributes
 
-    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
+    rescue Rasti::Model::UnexpectedAttributesError => ex
+      ex.attributes.each do |attr_name|
+        errors[attr_name] << 'unexpected attribute'
       end
-    end
 
-    def assigned_attribute_names
-      self.class.attribute_names & instance_variables.map { |v| v.to_s[1..-1].to_sym }
+    ensure
+      raise_if_errors!
     end
 
-    def serialize(value)
-      if value.kind_of? Array
-        value.map { |v| serialize v }
-      elsif value.kind_of? Form
-        value.attributes
-      else
-        value
-      end
-    end
+    def validate_type_casting!
+      cast_attributes!
 
-    def read_attribute(name)
-      instance_variable_get "@#{name}"
-    end
+    rescue Rasti::Types::CompoundError => ex
+      ex.errors.each do |key, messages|
+        errors[key] += messages
+      end
 
-    def write_attribute(name, value)
-      typed_value = value.nil? ? nil : self.class.attributes[name][:type].cast(value)
-      instance_variable_set "@#{name}", typed_value
+    ensure
+      raise_if_errors!
     end
 
-    def fetch(attribute)
-      attribute.to_s.split('.').inject(self) do |target, attr_name|
-        target.nil? ? nil : target.public_send(attr_name)
+    def assert_present(attr_name)
+      if !errors.key?(attr_name)
+        assert attr_name, assigned?(attr_name) && !public_send(attr_name).nil?, 'not present'
       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'
+    def assert_not_present(attr_name)
+      assert attr_name, !assigned?(attr_name) || public_send(attr_name).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_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_time_range(attribute_from, attribute_to)
-       assert attribute_from, public_send(attribute_from) <= public_send(attribute_to), 'invalid time range'
+    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_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/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       = '6.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', '~> 2.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