rasti-form 0.1.0

data/lib/rasti/form/types/uuid.rb

@@ -0,0 +1,19 @@
+module Rasti
+  class Form
+    module Types
+      class UUID
+        class << self
+
+          include Formatable
+
+          private
+
+          def format
+            /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}+$/
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/rasti/form/version.rb

@@ -0,0 +1,5 @@
+module Rasti
+  class Form
+    VERSION = '0.1.0'
+  end
+end

data/lib/rasti/form.rb

@@ -0,0 +1,173 @@
+require 'json'
+require 'multi_require'
+
+module Rasti
+  class Form
+
+    extend MultiRequire
+
+    require_relative_pattern 'form/*'
+    require_relative_pattern 'form/types/*'
+
+    class << self
+
+      def [](attributes)
+        Class.new(self) do
+          attributes.each do |name, type, options={}|
+            attribute name, type, options
+          end
+
+          def self.inherited(subclass)
+            subclass.instance_variable_set :@attributes, attributes.dup
+          end
+        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
+
+      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
+      assigned_attribute_names.each_with_object({}) do |name, hash|
+        hash[name] = serialize(read_attribute(name))
+      end
+    end
+    alias_method :to_h, :attributes
+
+    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
+    end
+
+    private
+
+    def assign_attributes(attrs={})
+      self.class.attribute_names.each do |name|
+        begin
+          write_attribute name, attrs[name] if attrs.key? name
+        
+        rescue CastError => error
+          errors[name] << error.message
+        
+        rescue ValidationError => error
+          error.errors.each do |inner_name, inner_errors| 
+            inner_errors.each { |message| errors["#{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
+      end
+    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
+    end
+
+    def fetch(attribute)
+      attribute.to_s.split('.').inject(self) do |target, attr_name|
+        target.nil? ? nil : target.public_send(attr_name)
+      end
+    end
+
+    def validate!
+      validate
+      raise ValidationError.new(errors) unless errors.empty?
+    end
+
+    def validate
+    end
+
+    def errors
+      @errors ||= Hash.new { |hash, key| hash[key] = [] }
+    end
+
+    def assert(key, condition, message)
+      return true if condition
+      
+      errors[key] << message
+      false
+    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'
+      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(', ')}"
+      end
+    end
+
+  end
+end

data/lib/rasti-form.rb

@@ -0,0 +1 @@
+require_relative 'rasti/form'

data/rasti-form.gemspec

@@ -0,0 +1,37 @@
+# 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.authors       = ['Gabriel Naiman']
+  spec.email         = ['gabynaiman@gmail.com']
+  spec.summary       = 'Forms validations and type casting'
+  spec.description   = 'Forms validations and type casting'
+  spec.homepage      = 'https://github.com/gabynaiman/rasti-form'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_runtime_dependency 'multi_require', '~> 1.0'
+
+  spec.add_development_dependency 'bundler', '~> 1.12'
+  spec.add_development_dependency 'rake', '~> 11.0'
+  spec.add_development_dependency 'minitest', '~> 5.0'
+  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

@@ -0,0 +1,7 @@
+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

data/spec/form_spec.rb

@@ -0,0 +1,310 @@
+require 'minitest_helper'
+
+describe Rasti::Form do
+  
+  let(:point_class) { Rasti::Form[x: Rasti::Form::Types::Integer, y: Rasti::Form::Types::Integer] }
+
+  let(:point_subclass) { Class.new point_class }
+  
+  def build_form(&block)
+    Class.new(Rasti::Form) do
+      class_eval &block
+    end
+  end
+
+  describe 'Initialization' do
+
+    it 'All attributes' do
+      point = point_class.new x: 1, y: 2
+      point.x.must_equal 1
+      point.y.must_equal 2
+      point.assigned?(:x).must_equal true
+      point.assigned?(:y).must_equal true
+    end
+
+    it 'Some attributes' do
+      point = point_class.new x: 1
+      point.x.must_equal 1
+      point.y.must_be_nil
+      point.assigned?(:x).must_equal true
+      point.assigned?(:y).must_equal false
+    end
+
+    it 'Whitout attributes' do
+      point = point_class.new
+      point.x.must_be_nil
+      point.y.must_be_nil
+      point.assigned?(:x).must_equal false
+      point.assigned?(:y).must_equal false
+    end
+
+    it 'Extra attributes' do
+      point = point_class.new z: 3
+      point.x.must_be_nil
+      point.y.must_be_nil
+      point.assigned?(:x).must_equal false
+      point.assigned?(:y).must_equal false
+      proc { point.z }.must_raise NoMethodError
+      point.attributes.must_be_empty
+    end
+
+    describe 'Casting' do
+
+      it 'Attribute' do
+        form = build_form do
+          attribute :text, Rasti::Form::Types::String
+        end
+
+        f = form.new text: 123
+        f.text.must_equal "123"
+      end
+
+      it 'Nested attributes' do
+        form = build_form do
+          attribute :range, Rasti::Form::Types::Form[min: Rasti::Form::Types::Integer, max: Rasti::Form::Types::Integer]
+        end
+
+        f = form.new range: {min: '1', max: '10'}
+        f.range.min.must_equal 1
+        f.range.max.must_equal 10
+      end
+
+      it 'Nested form' do
+        range = build_form do
+          attribute :min, Rasti::Form::Types::Integer
+          attribute :max, Rasti::Form::Types::Integer
+        end
+
+        form = build_form do
+          attribute :range, Rasti::Form::Types::Form[range]
+        end
+
+        f = form.new range: {min: '1', max: '10'}
+        f.range.min.must_equal 1
+        f.range.max.must_equal 10
+      end
+
+      it 'Invalid attributes' do
+        form = build_form do
+          attribute :boolean, Rasti::Form::Types::Boolean
+          attribute :number, Rasti::Form::Types::Integer
+        end
+
+        error = proc { form.new boolean: 'x', number: 'y' }.must_raise Rasti::Form::ValidationError
+        error.message.must_equal 'Validation error: {"boolean":["Invalid cast: \'x\' -> Rasti::Form::Types::Boolean"],"number":["Invalid cast: \'y\' -> Rasti::Form::Types::Integer"]}'
+      end
+
+      it 'Invalid nested attributes' do
+        form = build_form do
+          attribute :range, Rasti::Form::Types::Form[min: Rasti::Form::Types::Integer, max: Rasti::Form::Types::Integer]
+        end
+
+        error = proc { form.new range: {min: 'x', max: 'y'} }.must_raise Rasti::Form::ValidationError
+        error.message.must_equal "Validation error: {\"range.min\":[\"Invalid cast: 'x' -> Rasti::Form::Types::Integer\"],\"range.max\":[\"Invalid cast: 'y' -> Rasti::Form::Types::Integer\"]}"
+      end
+
+      it 'Invalid form attributes' do
+        range = build_form do
+          attribute :min, Rasti::Form::Types::Integer
+          attribute :max, Rasti::Form::Types::Integer
+        end
+
+        form = build_form do
+          attribute :range, Rasti::Form::Types::Form[range]
+        end
+
+        error = proc { form.new range: {min: 'x', max: 'y'} }.must_raise Rasti::Form::ValidationError
+        error.message.must_equal "Validation error: {\"range.min\":[\"Invalid cast: 'x' -> Rasti::Form::Types::Integer\"],\"range.max\":[\"Invalid cast: 'y' -> Rasti::Form::Types::Integer\"]}"
+      end
+
+    end
+
+  end
+
+  describe 'Defaults' do
+
+    it 'Value' do
+      form = build_form do
+        attribute :text, Rasti::Form::Types::String, default: 'xyz'
+      end
+
+      f = form.new
+      f.text.must_equal 'xyz'
+    end
+
+    it 'Block' do
+      form = build_form do
+        attribute :time_1, Rasti::Form::Types::Time['%F']
+        attribute :time_2, Rasti::Form::Types::Time['%F'], default: ->(f) { f.time_1 }
+      end
+
+      f = form.new time_1: Time.now
+      f.time_2.must_equal f.time_1
+    end
+
+  end
+
+  describe 'Validations' do
+
+    it 'Required' do
+      form = build_form do
+        attribute :text, Rasti::Form::Types::String
+
+        def validate
+          assert_present :text
+        end
+      end
+
+      error = proc { form.new }.must_raise Rasti::Form::ValidationError
+      error.message.must_equal 'Validation error: {"text":["not present"]}'
+    end
+
+    it 'Not empty string' do
+      form = build_form do
+        attribute :text, Rasti::Form::Types::String
+
+        def validate
+          assert_not_empty :text
+        end
+      end
+
+      error = proc { form.new text: '  ' }.must_raise Rasti::Form::ValidationError
+      error.message.must_equal 'Validation error: {"text":["is empty"]}'
+    end
+
+    it 'Not empty array' do
+      form = build_form do
+        attribute :array, Rasti::Form::Types::Array[Rasti::Form::Types::String]
+
+        def validate
+          assert_not_empty :array
+        end
+      end
+
+      error = proc { form.new array: [] }.must_raise Rasti::Form::ValidationError
+      error.message.must_equal 'Validation error: {"array":["is empty"]}'
+    end
+
+    it 'Included in values list' do
+      form = build_form do
+        attribute :text, Rasti::Form::Types::String
+
+        def validate
+          assert_included_in :text, %w(value_1 value_2)
+        end
+      end
+
+      error = proc { form.new text: 'xyz' }.must_raise Rasti::Form::ValidationError
+      error.message.must_equal 'Validation error: {"text":["not included in \'value_1\', \'value_2\'"]}'
+    end
+
+    it 'Nested form' do
+      form = build_form do
+        attribute :range, Rasti::Form::Types::Form[min: Rasti::Form::Types::Integer, max: Rasti::Form::Types::Integer]
+
+        def validate
+          assert_present 'range.min'
+          assert_present 'range.max'
+        end
+      end
+
+      error = proc { form.new }.must_raise Rasti::Form::ValidationError
+      error.message.must_equal 'Validation error: {"range.min":["not present"],"range.max":["not present"]}'
+    end
+
+    it 'Nested validation' do
+      range = build_form do
+        attribute :min, Rasti::Form::Types::Integer
+        attribute :max, Rasti::Form::Types::Integer
+
+        def validate
+          assert :min, min < max, 'Min must be less than Max' if min && max
+        end
+      end
+
+      form = build_form do
+        attribute :range, Rasti::Form::Types::Form[range]
+      end 
+
+      error = proc { form.new range: {min: 2, max: 1} }.must_raise Rasti::Form::ValidationError
+      error.message.must_equal 'Validation error: {"range.min":["Min must be less than Max"]}'
+    end
+
+  end
+
+  describe 'Comparable' do
+
+    it 'Equivalency (==)' do
+      point_1 = point_class.new x: 1, y: 2
+      point_2 = point_subclass.new x: 1, y: 2
+      point_3 = point_class.new x: 2, y: 1
+
+      assert point_1 == point_2
+      refute point_1 == point_3
+    end
+    
+    it 'Equality (eql?)' do
+      point_1 = point_class.new x: 1, y: 2
+      point_2 = point_class.new x: 1, y: 2
+      point_3 = point_subclass.new x: 1, y: 2
+      point_4 = point_class.new x: 2, y: 1
+
+      assert point_1.eql?(point_2)
+      refute point_1.eql?(point_3)
+      refute point_1.eql?(point_4)
+    end
+
+    it 'hash' do
+      point_1 = point_class.new x: 1, y: 2
+      point_2 = point_class.new x: 1, y: 2
+      point_3 = point_subclass.new x: 1, y: 2
+      point_4 = point_class.new x: 2, y: 1
+
+      point_1.hash.must_equal point_2.hash
+      point_1.hash.wont_equal point_3.hash
+      point_1.hash.wont_equal point_4.hash
+    end
+
+  end
+
+  it 'Attributes (to_h)' do
+    t = Rasti::Form::Types
+    address_class = Rasti::Form[street: t::String, number: t::Integer]
+    contact_class = Rasti::Form[
+      name: t::String, 
+      age: t::Integer, 
+      phones: t::Hash[t::Symbol, t::Integer], 
+      addresses: t::Array[t::Form[address_class]]
+    ]
+
+    attributes = {
+      name: 'John', 
+      age: 24, 
+      phones: {
+        office: 1234567890, 
+        house:  456456456
+      },
+      addresses: [
+        {street: 'Lexington Avenue', number: 123},
+        {street: 'Park Avenue',      number: 456}
+      ]
+    }
+
+    contact = contact_class.new attributes
+
+    contact.attributes.must_equal attributes
+    contact.attributes.must_equal contact.to_h
+  end
+
+  it 'to_s' do
+    point_class.to_s.must_equal 'Rasti::Form[:x, :y]'
+    point_class.new(x: '1', y: '2').to_s.must_equal '#<Rasti::Form[x: 1, y: 2]>'
+  end
+
+  it 'Subclass' do
+    point = point_subclass.new x: 1, y: 2
+    point.x.must_equal 1
+    point.y.must_equal 2
+  end
+
+end

data/spec/minitest_helper.rb

@@ -0,0 +1,13 @@
+require 'coverage_helper'
+require 'minitest/autorun'
+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

data/spec/types/array_spec.rb

@@ -0,0 +1,22 @@
+require 'minitest_helper'
+
+describe Rasti::Form::Types::Array do
+
+  array = [1, '2', Time.now]
+  
+  it "#{array.inspect} -> #{array.map(&:to_i)}" do
+    Rasti::Form::Types::Array[Rasti::Form::Types::Integer].cast(array).must_equal array.map(&:to_i)
+  end
+
+  it "#{array.inspect} -> #{array.map(&:to_s)}" do
+    Rasti::Form::Types::Array[Rasti::Form::Types::String].cast(array).must_equal array.map(&:to_s)
+  end
+
+  [[nil], nil, 1, 'text', :symbol, {a: 1, b: 2}, Object.new].each do |value|
+    it "#{value.inspect} -> CastError" do
+      error = proc { Rasti::Form::Types::Array[Rasti::Form::Types::String].cast(value) }.must_raise Rasti::Form::CastError
+      error.message.must_equal "Invalid cast: #{as_string(value)} -> Rasti::Form::Types::Array[Rasti::Form::Types::String]"
+    end
+  end
+
+end

data/spec/types/boolean_spec.rb

@@ -0,0 +1,24 @@
+require 'minitest_helper'
+
+describe Rasti::Form::Types::Boolean do
+  
+  [true, 'true', 'True', 'TRUE', 'T'].each do |value|
+    it "#{value.inspect} -> true" do
+      Rasti::Form::Types::Boolean.cast(value).must_equal true
+    end
+  end
+
+  [false, 'false', 'False', 'FALSE', 'F'].each do |value|
+    it "#{value.inspect} -> false" do
+      Rasti::Form::Types::Boolean.cast(value).must_equal false
+    end
+  end
+
+  [nil, 'text', 123, :false, :true, Time.now, [1,2], {a: 1, b: 2}, Object.new].each do |value|
+    it "#{value.inspect} -> CastError" do
+      error = proc { Rasti::Form::Types::Boolean.cast(value) }.must_raise Rasti::Form::CastError
+      error.message.must_equal "Invalid cast: #{as_string(value)} -> Rasti::Form::Types::Boolean"
+    end
+  end
+
+end

data/spec/types/enum_spec.rb

@@ -0,0 +1,20 @@
+require 'minitest_helper'
+
+describe Rasti::Form::Types::Enum do
+
+  enum = Rasti::Form::Types::Enum[:a,:b,:c]
+
+  [:a, 'b', "c"].each do |value|
+    it "#{value.inspect} -> #{enum}" do
+      Rasti::Form::Types::Enum[:a,:b,:c].cast(value).must_equal value.to_s
+    end
+  end
+
+  [nil, 'text', :symbol, '999'.to_sym, [1,2], {a: 1, b: 2}, Object.new].each do |value|
+    it "#{value.inspect} -> CastError" do
+      error = proc { Rasti::Form::Types::Enum[:a,:b,:c].cast(value) }.must_raise Rasti::Form::CastError
+      error.message.must_equal "Invalid cast: #{as_string(value)} -> Rasti::Form::Types::Enum[\"a\", \"b\", \"c\"]"
+    end
+  end
+
+end

data/spec/types/float_spec.rb

@@ -0,0 +1,18 @@
+require 'minitest_helper'
+
+describe Rasti::Form::Types::Float do
+  
+  [100, '200', Time.now,2.0,"12.5"].each do |value|
+    it "#{value.inspect} -> #{value.to_i}" do
+      Rasti::Form::Types::Float.cast(value).must_equal value.to_f
+    end
+  end
+
+  [nil, 'text', :symbol, '999'.to_sym, [1,2], {a: 1, b: 2}, Object.new, "1.", ".2","."].each do |value|
+    it "#{value.inspect} -> CastError" do
+      error = proc { Rasti::Form::Types::Float.cast(value) }.must_raise Rasti::Form::CastError
+      error.message.must_equal "Invalid cast: #{as_string(value)} -> Rasti::Form::Types::Float"
+    end
+  end
+
+end