rasti-form 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b3dad1f53996c5b3093f6c924b8475b64ae9826d
+  data.tar.gz: 572457d753e9fd911b3c1ea4780bdfd32b0760f7
+SHA512:
+  metadata.gz: b09a249237c1b4b324e67dcad8c19ee504d0ed741098eb0766f99379f0a011088694dc695e5ac3bdb88435135af78a9d0d63ed045294974aae95e7242ed1fa4f
+  data.tar.gz: 397de77010d7955fadf05b57f5bb189562c17c92c52d2001b43661c06d59f9db1a2d639b55ad0bf354c76f6f46d590a65d6a4dc8b42a8e36ec93a22fd5730c30

data/.coveralls.yml

@@ -0,0 +1,2 @@
+service_name: travis-ci
+repo_token: 0EGMDDynKz8NseenfliuxtLQ94b2Kg2MN

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.ruby-gemset

@@ -0,0 +1 @@
+rasti-form

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.3.0

data/.travis.yml

@@ -0,0 +1,11 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0
+  - 2.1
+  - 2.2
+  - 2.3.0
+  - 2.4.0
+  - jruby
+before_install:
+  - gem install bundler

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rasti-form.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Gabriel Naiman
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,131 @@
+# 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)
+[![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
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rasti-form'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rasti-form
+
+## 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
+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}
+
+PointForm.new x: true # => Validation error: {"x":["Invalid cast: true -> Rasti::Form::Types::Integer"]}
+```
+
+### Form validations
+
+```ruby
+class DateRangeForm < Rasti::Form
+  TIME_FORMAT = '%d/%m/%Y'
+
+  attribute :from, T::Time[TIME_FORMAT]
+  attribute :to,   T::Time[TIME_FORMAT]
+
+  private
+
+  def validate
+    assert_present :from
+    assert_present :to
+    assert :from, from <= to, 'From must be less than To' if from && to
+  end
+end
+
+DateRangeForm.new # => Validation error: {"from":["not present"],"to":["not present"]}
+DateRangeForm.new from: '20/10/2016', to: '08/10/2016' # => Validation error: {"from":["From must be less than To"]}
+
+form = DateRangeForm.new from: '20/10/2016', to: '28/10/2016'
+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
+- Hash
+- Integer
+- Regexp
+- String
+- Struct
+- 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.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,24 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new(:spec) do |t|
+  t.libs << 'spec'
+  t.pattern = 'spec/**/*_spec.rb'
+  t.verbose = false
+  t.warning = false
+  t.loader = nil if ENV['TEST']
+  ENV['TEST'], ENV['LINE'] = ENV['TEST'].split(':') if ENV['TEST'] && !ENV['LINE']
+  t.options = ''
+  t.options << "--name=/#{ENV['NAME']}/ " if ENV['NAME']
+  t.options << "-l #{ENV['LINE']} " if ENV['LINE'] && ENV['TEST']
+end
+
+task default: :spec
+
+desc 'Pry console'
+task :console do
+  require 'rasti-form'
+  require 'pry'
+  ARGV.clear
+  Pry.start
+end

data/lib/rasti/form/castable.rb

@@ -0,0 +1,25 @@
+module Rasti
+  class Form
+    module Castable
+
+      def cast(value)
+        if valid? value
+          transform! value
+        else
+          raise CastError.new self, value
+        end
+      end
+
+      private
+
+      def transform!(value)
+        transform value
+      rescue ValidationError => ex
+        raise ex
+      rescue
+        raise CastError.new self, value
+      end
+
+    end
+  end
+end

data/lib/rasti/form/errors.rb

@@ -0,0 +1,41 @@
+module Rasti
+  class Form
+    
+    class CastError < StandardError
+
+      attr_reader :type, :value
+
+      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 ValidationError < StandardError
+
+      attr_reader :errors
+      
+      def initialize(errors)
+        @errors = errors
+      end
+
+      def message
+        "Validation error: #{JSON.dump(errors)}"
+      end
+
+    end
+
+  end
+end

data/lib/rasti/form/formatable.rb

@@ -0,0 +1,19 @@
+module Rasti
+  class Form
+    module Formatable
+
+      include Castable
+
+      private
+
+      def valid?(value)
+        (value.is_a?(::String) || value.is_a?(Symbol)) && value.to_s.match(format)
+      end
+
+      def transform(value)
+        value
+      end
+      
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+module Rasti
+  class Form
+    module Types
+      class Array
+
+        include Castable
+
+        attr_reader :type
+
+        def self.[](type)
+          new type
+        end
+
+        def to_s
+          "#{self.class}[#{type}]"
+        end
+        alias_method :inspect, :to_s
+
+        private
+
+        def initialize(type)
+          @type = type
+        end
+
+        def valid?(value)
+          value.is_a? ::Array
+        end
+
+        def transform(value)
+          value.map { |e| type.cast e }
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+module Rasti
+  class Form
+    module Types
+      class Boolean
+        class << self
+
+          include Castable
+
+          TRUE_FORMAT  = /^t(rue)?$/i
+          FALSE_FORMAT = /^f(alse)?$/i
+        
+          private
+
+          def valid?(value)
+            boolean?(value) || valid_string?(value)
+          end
+
+          def transform(value)
+            boolean?(value) ? value : true_string?(value)
+          end
+
+          def boolean?(value)
+            value == true || value == false
+          end
+
+          def valid_string?(value)
+            value.is_a?(::String) && (true_string?(value) || false_string?(value))
+          end
+
+          def true_string?(value)
+            !!value.match(TRUE_FORMAT)
+          end
+
+          def false_string?(value)
+            !!value.match(FALSE_FORMAT)
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+module Rasti
+  class Form
+    module Types
+      class Enum
+
+        include Castable
+
+        attr_reader :values
+
+        def self.[](*values)
+          new values
+        end
+
+        def to_s
+          "#{self.class}[#{values.map(&:inspect).join(', ')}]"
+        end
+        alias_method :inspect, :to_s
+
+        private
+
+        def initialize(values)
+          @values = values.map(&:to_s)
+        end
+
+        def valid?(value)
+          values.include? String.cast(value)
+        rescue
+          false
+        end
+
+        def transform(value)
+          String.cast value
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+module Rasti
+  class Form
+    module Types
+      class Float
+        class << self
+
+          include Castable
+
+          FORMAT = /^(\d+\.)?\d+$/
+        
+          private
+
+          def valid?(value)
+            !value.nil? && (valid_string?(value) || transformable?(value))
+          end
+
+          def transform(value)
+            value.to_f
+          end
+
+          def valid_string?(value)
+            value.is_a?(::String) && value.match(FORMAT)
+          end
+
+          def transformable?(value)
+            !value.is_a?(::String) && value.respond_to?(:to_f)
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+module Rasti
+  class Form
+    module Types
+      class Form
+
+        include Castable
+
+        attr_reader :form_class
+
+        def self.[](*args)
+          new *args
+        end
+
+        def to_s
+          "#{self.class}[#{form_class}]"
+        end
+        alias_method :inspect, :to_s
+
+        private
+
+        def initialize(form)
+          @form_class = case
+            when form.is_a?(::Hash) then Rasti::Form[form]
+            when form.is_a?(Class) && form.ancestors.include?(Rasti::Form) then form
+            else raise ArgumentError, "Invalid form specification: #{form.inspect}"
+          end
+        end
+
+        def valid?(value)
+          value.is_a? ::Hash
+        end
+
+        def transform(value)
+          form_class.new value
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+module Rasti
+  class Form
+    module Types
+      class Hash
+        
+        include Castable
+
+        attr_reader :key_type, :value_type
+
+        def self.[](key_type, value_type)
+          new key_type, value_type
+        end
+
+        def to_s
+          "#{self.class}[#{key_type}, #{value_type}]"
+        end
+        alias_method :inspect, :to_s
+
+        private
+
+        def initialize(key_type, value_type)
+          @key_type = key_type
+          @value_type = value_type
+        end
+
+        def valid?(value)
+          value.is_a? ::Hash
+        end
+
+        def transform(value)
+          value.each_with_object({}) do |(k,v),h| 
+            h[key_type.cast k] = value_type.cast v
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module Rasti
+  class Form
+    module Types
+      class Integer < Float
+        class << self
+        
+          private
+
+          def transform(value)
+            value.to_i
+          end
+
+          def transformable?(value)
+            !value.is_a?(::String) && value.respond_to?(:to_i)
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module Rasti
+  class Form
+    module Types
+      class Regexp
+
+        include Formatable
+
+        def self.[](format)
+          new format
+        end
+
+        def to_s
+          "#{self.class}[#{format.inspect}]"
+        end
+        alias_method :inspect, :to_s
+
+        private
+        
+        attr_reader :format
+
+        def initialize(format)
+          @format = format.is_a?(String) ? ::Regexp.new(format) : format
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module Rasti
+  class Form
+    module Types
+      class String
+        class << self
+
+          include Castable
+        
+          private
+
+          def valid?(value)
+            !value.nil? && value.respond_to?(:to_s)
+          end
+
+          def transform(value)
+            value.to_s
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module Rasti
+  class Form
+    module Types
+      class Symbol
+        class << self
+
+          include Castable
+        
+          private
+
+          def valid?(value)
+            !value.nil? && (value.respond_to?(:to_sym) || value.respond_to?(:to_s))
+          end
+
+          def transform(value)
+            value.respond_to?(:to_sym) ? value.to_sym : value.to_s.to_sym
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+module Rasti
+  class Form
+    module Types
+      class Time
+
+        include Castable
+
+        attr_reader :format
+
+        def self.[](format)
+          new format
+        end
+
+        def to_s
+          "#{self.class}['#{format}']"
+        end
+        alias_method :inspect, :to_s
+
+        private
+
+        def initialize(format)
+          @format = format
+        end
+
+        def valid?(value)
+          value.is_a?(::String) || value.respond_to?(:to_time)
+        end
+
+        def transform(value)
+          value.is_a?(::String) ? string_to_time(value) : value.to_time
+        end
+
+        def string_to_time(value)
+          ::Time.strptime(value, format)
+        end
+
+      end
+    end
+  end
+end