safe_type 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: eca25594ac5b8d10503472a6adc49dba43091c3f
-  data.tar.gz: c469b2f8539bc78995b69b200757c0c420997b75
+  metadata.gz: a67c63237e5cf69ced4be0ee3a485f7ff3fba588
+  data.tar.gz: f92d5b559d4a2cbf322187f2f4eef1d17d7967a5
 SHA512:
-  metadata.gz: 8f56662fd4b888c637db732c23d9248d14691af30d95499fd73e511d1cff836c5816f22b816960c9c0bcbb65aecc08f7a11f037cb9023a762d58b5bb925b3e3d
-  data.tar.gz: 4b3bc19ab41437031109d8922a9187623a5912e0dd295ab3461e26c80a44e98b5f031d0a4c15e14e1da7f552d401ab60589c14bac1cc0c5a692493b5fa3f76e9
+  metadata.gz: 6fab8fcf295c05a748678d0ed5f4770797f8b83c3d637fe5e70eedb0fd62f405f8703577a4dd2cfb7f45efb515437c8bc7064f6f993c945a2dc80c5d84db519d
+  data.tar.gz: 311fe81e529e0f948cbefadf8d2efea6cd992897a692468c253579f50ad2606f663c890bad05d22037da850a55d76abf4dcd46ef6a879fc503b2bd527ea3f756

data/README.md

@@ -1,16 +1,17 @@
-# SafeType
+SafeType
+======
 [![Gem Version](https://badge.fury.io/rb/safe_type.svg)](https://badge.fury.io/rb/safe_type)
 [![Build Status](https://travis-ci.org/chanzuckerberg/safe_type.svg?branch=master)](https://travis-ci.org/chanzuckerberg/safe_type)
 [![Maintainability](https://api.codeclimate.com/v1/badges/7fbc9a4038b86ef639e1/maintainability)](https://codeclimate.com/github/chanzuckerberg/safe_type/maintainability)
 [![Test Coverage](https://api.codeclimate.com/v1/badges/7fbc9a4038b86ef639e1/test_coverage)](https://codeclimate.com/github/chanzuckerberg/safe_type/test_coverage)
 
-While working with environment variables, routing parameters, JSON objects,
+While working with environment variables, routing parameters, API responses,
   or other Hash-like objects require parsing,
-  we often require type coercion to assure expected behaviors.
+  we often need type coercion to assure expected behaviors.
 
 ***SafeType*** provides an intuitive type coercion interface and type enhancement.
 
-## Install
+# Install
 
 We can install `safe_type` using `gem install`: 
 
@@ -24,118 +25,158 @@ Or we can add it as a dependency in the `Gemfile` and run `bundle install`:
 gem 'safe_type'
 ```
 
-## Usage
-Using `SafeType` namespace:
+# Use Cases
+## Environment Variables
 ```ruby
-require 'safe_type'
-
-SafeType::coerce("SafeType", SafeType::Required::String)
-```
-
-### Coercion with Default Value
-```ruby
-SafeType::coerce("true", SafeType::Default::Boolean(false))   # => true
-SafeType::coerce(nil, SafeType::Default::Boolean(false))      # => false
-SafeType::coerce("a", SafeType::Default::Symbol(:a))          # => :a
-SafeType::coerce("123", SafeType::Default::Integer(nil))      # => 123
-SafeType::coerce("1.0", SafeType::Default::Float(nil))        # => 1.0
-SafeType::coerce("2018-06-01", SafeType::Default::Date(nil))
-# => #<Date: 2018-06-01 ((2458271j,0s,0n),+0s,2299161j)>
+require 'safe_type/mixin/hash' # symbolize_keys
+
+ENV["DISABLE_TASKS"] = "true"
+ENV["API_KEY"] = ""
+ENV["BUILD_NUM"] = "123"
+SAFE_ENV = SafeType::coerce(
+  ENV,
+  {
+    "DISABLE_TASKS" => SafeType::Boolean.default(false),
+    "API_KEY" => SafeType::String.default("SECRET"),
+    "BUILD_NUM" => SafeType::Integer.strict,
+  }
+).symbolize_keys
+
+SAFE_ENV[:DISABLE_TASKS]    # => true
+SAFE_ENV[:API_KEY]          # => SECRET
+SAFE_ENV[:BUILD_NUM]        # => 123
 ```
-### Coercion with Required Value
+## Routing Parameters
 ```ruby
-SafeType::coerce("true", SafeType::Required::Boolean)         # => true
-SafeType::coerce(nil, SafeType::Required::Boolean)            # => SafeType::CoercionError 
-SafeType::coerce("123!", SafeType::Required::Integer)         # => SafeType::CoercionError
-```
+class FallSemester < SafeType::Date
+  # implement validate method
+end
 
-### Coercion Rule
-Under the hood, all `SafeType::Required` and `SafeType::Default` modules are just
-methods for creating coercion rules. A coercion rule has to be described as a hash, 
-with a required key `type`.
-```ruby
-r = Rule.new(type: Integer)
-```
-A coercion rules support other parameters such as:
-- `required`: If a value is `nil` and has a rule with `required`,
-    it will raise an exception.
-- `default`: If a value is `nil` (not present or failed to convert),
-    it will be filled with the default.
-- `before`: A method will be called before the coercion,
-    which takes the value to coerce as input.
-- `after`: A method will be called after the coercion,
-    which takes the coercion result as input. 
-- `validate`: A method will be called to validate the input,
-    which takes the value to coerce as input. It returns `true` or `false`.
-    It will empty the value to `nil` if the validation method returns `false`.
-
-### Coerce By Rules
-Coercion can by defined a set of coercion rules.
-If the input is hash-like, then the rules shall be described as the values,
-  for each key we want to coerce in the input. 
-
-`coerce!` is a mutating method, which modifies the values in place.
-
-```ruby
-RequiredRecentDate = SafeType::Rule.new(
-  type: Date, required: true, after: lambda { |date|
-    date if date >= Date.new(2000, 1, 1) && date <= Date.new(2020, 1, 1)
-  })
-
-# => <Date: 2015-01-01 ((2457024j,0s,0n),+0s,2299161j)> 
-SafeType::coerce("2015-01-01", RequiredRecentDate) 
-# SafeType::CoercionError
-SafeType::coerce("3000-01-01", RequiredRecentDate)
-```
-Note mutating coercion can only be applied on a hash-like object.
+current_year = Date.today.year
+params = {
+  "course_id" => "101",
+  "start_date" => "#{current_year}-10-01"
+}
 
-```ruby
-# ArgumentError: mutating coercion can only be applied on a hash-like object
-SafeType::coerce!("1", Rule.new(type: Integer))
-```
+rules = {
+  "course_id" => SafeType::Integer.strict,
+  "start_date" => FallSemester.strict
+}
 
-### Coerce Environment Variables
-We have to use `String` key and values in `ENV`. 
-Here is an example of type coercion on `ENV`.
+SafeType::coerce!(params, rules)
 
-```ruby
-ENV["FLAG_0"] = "true"
-ENV["FLAG_1"] = "false"
-ENV["NUM_0"] = "123"
-
-h = SafeType::coerce(ENV, {
-  FLAG_0: SafeType::Default::Boolean(false),
-  FLAG_1: SafeType::Default::Boolean(false),
-  NUM_0: SafeType::Default::Integer(0),
-}.stringify_keys).symbolize_keys 
-
-h[:FLAG_0]   # => true
-h[:FLAG_1]   # => false
-h[:NUM_0]    # => 123
+params["course_id"]       # => 101
+params["start_date"]      # => <Date: 2018-10-01 ((2458393j,0s,0n),+0s,2299161j)>
 ```
-
-### Coerce Hash-like Objects
+## JSON Response
 ```ruby
-params = {
-  scores: ["5.0", "3.5", "4.0", "2.2"],
-  names: ["a", "b", "c", "d"],
+json = {
+  "names" => ["Alice", "Bob", "Chris"],
+  "info" => [
+    {
+      "type" => "dog",
+      "age" => "5",
+    },
+    {
+      "type" => "cat",
+      "age" => "4",
+    },
+    {
+      "type" => "fish",
+      "age" => "6",
+    }
+  ]
 }
 
-SafeType::coerce!(params, {
-  scores: [SafeType::Required::Float],
-  names: [SafeType::Required::String],
+SafeType::coerce!(json, {
+  "names" => [SafeType::String.strict],
+  "info" => [
+    {
+      "type" => SafeType::String.strict,
+      "age" => SafeType::Integer.strict
+    }
+  ]
 })
+```
+## Http Response
+```ruby
+class ResponseType; end
 
-params[:scores]   # => [5.0, 3.5, 4.0, 2.2]
-params[:names]    # => ["a", "b", "c", "d"]
+class Response < SafeType::Rule
+  def initialize(type: ResponseType, default: "404")
+    super
+  end
+
+  def before(uri)
+    # make request
+    return ResponseType.new 
+  end
+end
+
+Response["https://API_URI"]   # => #<ResponseType:0x000056005b3e7518>
 ```
 
-## Prior Art
+# Overview 
+A `Rule` describes a single transformation pipeline. It's the core of this gem.
+```ruby
+class Rule
+  def initialize(type:, default: nil, required: false)
+```
+The parameters are
+- the `type` to transform into
+- the `default` value when the result is `nil`
+- `required` indicates whether empty values are allowed
+
+## `strict` vs `default`
+The primitive types in *SafeType* provide `default` and `strict` mode, which are
+- `SafeType::Boolean`
+- `SafeType::Date`
+- `SafeType::DateTime`
+- `SafeType::Float`
+- `SafeType::Integer`
+- `SafeType::String`
+- `SafeType::Symbol`
+- `SafeType::Time`
+
+Under the hood, they are all just SafeType rules.
+- `default`: a rule with default value specified
+- `strict`: a rule with `required: true`, so no empty values are allowed, or it throws `EmptyValueError`
+
+## Apply the rules
+As we've seen in the use cases, we can call `coerce` to apply a set of `SafeType::Rule`s.
+Rules can be bundled together as elements in an array or values in a hash.
+
+### `coerce` vs `coerce!`
+- `SafeType::coerce` returns a new object, corresponding to the rules. The unspecified fields will not be included in the new object.
+- `SafeType::coerce!` coerces the object in place. The unspecified fields will not be modified.
+Note `SafeType::coerce!` cannot be used on a simple object, otherwise it will raise `SafeType::InvalidRuleError`. 
+
+To apply the rule on a simple object, we can call `[]` method as well.
+```ruby
+SafeType::Integer.default["1"]    # => 1
+SafeType::Integer["1"]            # => 1
+```
+For the *SafeType* primitive types, apply the rule on the class itself will use the default rule.
+
+## Customized Types
+We can inherit from a `SafeType::Rule` to create a customized type.
+We can override following methods if needed:
+- Override `initialize` to change the default values, types, or add more attributes.
+- Override `before` to update the input before convert. This method should take the input and return it after processing.
+- Override `validate` to check the value after convert. This method should take the input and return `true` or `false`.
+- Override `after` to update the input after validate. This method should take the input and return it after processing.
+- Override `handle_exceptions` to change the behavior of exceptions handling (e.g: send to the logger, or no exception) 
+- Override `default` or `strict` to modify the default and strict rule.
+
+# Prior Art
 This gem was inspired by [rails_param](https://github.com/nicolasblanco/rails_param)
-and [dry-types](https://github.com/dry-rb/dry-types). `dry-types` forces on setting
-constrains when creating new object instances. `rails_param` replies on Rails and it is
-only for the `params`. Therefore, `safe_type` was created. It integrated some ideas from both
-gems, and it was designed specifically for type checking to provide an clean and easy-to-use interface.
+and [dry-types](https://github.com/dry-rb/dry-types). `dry-types` has a complex interface. 
+Also it does not support in place coercion, and it will be complicated to `ENV` since the design of its
+`Hash Schemas`. `rails_param` relies on Rails and it is only for the `params`. 
+Therefore, `safe_type` was created. It integrated some ideas from both gems, 
+and it was designed specifically for type checking to provide an clean and easy-to-use interface.
+It should be useful when working with any string or hash where the values are coming from an external source, 
+such as `ENV` variables, rails `params`, or API calls.
 
 ## License
 `safe_type` is released under an MIT license.

data/lib/safe_type.rb

@@ -1,249 +1,59 @@
-require 'date'
-require 'time'
+require 'safe_type/rule'
+require 'safe_type/errors'
+
+require 'safe_type/primitive/boolean'
+require 'safe_type/primitive/date'
+require 'safe_type/primitive/date_time'
+require 'safe_type/primitive/float'
+require 'safe_type/primitive/integer'
+require 'safe_type/primitive/string'
+require 'safe_type/primitive/symbol'
+require 'safe_type/primitive/time'
 
 module SafeType
-  module Boolean; end
-
-  module HashHelper
-    def stringify_keys
-      Hash[self.map{ |key, val| [key.to_s, val] }]
-    end
-    def symbolize_keys
-      Hash[self.map{ |key, val| [key.to_sym, val] }]
-    end
-  end
-
-  class Converter
-    @@TRUE_VALUES = %w[on On ON t true True TRUE T y yes Yes YES Y].freeze
-    @@FALSE_VALUES = %w[off Off OFF f false False FALSE F n no No NO N].freeze
-    @@METHODS = [:to_true, :to_false, :to_int, :to_float, :to_date, :to_date_time,
-      :to_time].freeze
-
-    def self.to_true(input)
-      true if @@TRUE_VALUES.include?(input.to_s)
-    end
-
-    def self.to_false(input)
-      false if @@FALSE_VALUES.include?(input.to_s)
-    end
-
-    def self.to_bool(input)
-      return true unless self.to_true(input).nil?
-      return false unless self.to_false(input).nil?
-    end
-
-    def self.to_int(input)
-      Integer(input, base=10)
-    end
-
-    def self.to_float(input)
-      Float(input)
-    end
-
-    def self.to_date(input)
-      return input unless input.respond_to?(:to_str)
-      Date.parse(input)
-    end
-
-    def self.to_date_time(input)
-      return input unless input.respond_to?(:to_str)
-      DateTime.parse(input)
-    end
-
-    def self.to_time(input)
-      return input unless input.respond_to?(:to_str)
-      Time.parse(input)
-    end
-
-    def self.to_type(input, type)
-      return input if input.is_a?(type)
-      return input.to_s if type == String
-      return input.to_sym if type == Symbol
-      return self.to_true(input) if type == TrueClass
-      return self.to_false(input) if type == FalseClass
-      return self.to_bool(input) if type == Boolean
-      return self.to_int(input) if type == Integer
-      return self.to_float(input) if type == Float
-      return self.to_date(input) if type == Date
-      return self.to_date_time(input) if type == DateTime
-      return self.to_time(input) if type == Time
-      return type.try_convert(input) if type.respond_to?(:try_convert)
-      return type.new(input) if type.respond_to?(:new)
-    end
-  end
-
-  class CoercionError < TypeError
-    def initialize(msg="unable to transform the input into the requested type.")
-      super
-    end
-  end
-
-  class Rule
-    attr_reader :type, :default, :before, :after, :validate
-    def initialize(r)
-      raise ArgumentError, "SafeType::Rule has to be descried as a hash" \
-        unless r.class == ::Hash
-      raise ArgumentError, ":type key is required" \
-        unless r.has_key?(:type)
-      raise ArgumentError, ":type has to a class or module" \
-        unless r[:type].class == ::Class || r[:type].class == ::Module
-      @type = r[:type]
-      @required = false
-      @required = true if r.has_key?(:required) && r[:required]
-      @has_default = r.has_key?(:default)
-      @default = r[:default]
-      @before = r[:before]
-      @after = r[:after]
-      @validate = r[:validate]
-    end
-
-    def required?; @required; end
-
-    def has_default?; @has_default; end
-
-    def apply(input)
-      input = @before[input] unless @before.nil?
-      begin
-        result = Converter.to_type(input, @type) \
-          if @validate.nil? || (!@validate.nil? && @validate[input])
-      rescue
-        return @default if @has_default
-        return nil unless @required
-      end
-      result = @after[result] unless @after.nil?
-      raise CoercionError if result.nil? && @required
-      return @default if result.nil?
-      result
-    end
-  end
-
-  module Default
-    def self.String(val, validate: nil, before: nil, after: nil)
-      Rule.new(type: String, default: val, validate: validate, before: before, after: after)
-    end
-
-    def self.Symbol(val, validate: nil, before: nil, after: nil)
-      Rule.new(type: Symbol, default: val, validate: validate, before: before, after: after)
-    end
-
-    def self.Boolean(val, validate: nil, before: nil, after: nil)
-      Rule.new(type: Boolean, default: val, validate: validate, before: before, after: after)
-    end
-
-    def self.Integer(val, validate: nil, before: nil, after: nil)
-      Rule.new(type: Integer, default: val, validate: validate, before: before, after: after)
-    end
-
-    def self.Float(val, validate: nil, before: nil, after: nil)
-      Rule.new(type: Float, default: val, validate: validate, before: before, after: after)
-    end
-
-    def self.Date(val, validate: nil, before: nil, after: nil)
-      Rule.new(type: Date, default: val, validate: validate, before: before, after: after)
-    end
-
-    def self.DateTime(val, validate: nil, before: nil, after: nil)
-      Rule.new(type: DateTime, default: val, validate: validate, before: before, after: after)
-    end
-
-    def self.Time(val, validate: nil, before: nil, after: nil)
-      Rule.new(type: Time, default: val, validate: validate, before: before, after: after)
-    end
-  end
-
-  module Required
-    def self.String(validate: nil, before: nil, after: nil)
-      Rule.new(type: ::String, required: true, validate: validate, before: before, after: after)
-    end
-
-    def self.Symbol(validate: nil, before: nil, after: nil)
-      Rule.new(type: ::Symbol, required: true, validate: validate, before: before, after: after)
-    end
-
-    def self.Boolean(validate: nil, before: nil, after: nil)
-      Rule.new(type: SafeType::Boolean, required: true, validate: validate,
-               before: before, after: after)
-    end
-
-    def self.Integer(validate: nil, before: nil, after: nil)
-      Rule.new(type: ::Integer, required: true, validate: validate, before: before, after: after)
-    end
-
-    def self.Float(validate: nil, before: nil, after: nil)
-      Rule.new(type: ::Float, required: true, validate: validate, before: before, after: after)
-    end
-
-    def self.Date(validate: nil, before: nil, after: nil)
-      Rule.new(type: ::Date, required: true, validate: validate, before: before, after: after)
-    end
-
-    def self.DateTime(validate: nil, before: nil, after: nil)
-      Rule.new(type: ::DateTime, required: true, validate: validate, before: before, after: after)
-    end
-
-    def self.Time(validate: nil, before: nil, after: nil)
-      Rule.new(type: ::Time, required: true, validate: validate, before: before, after: after)
-    end
-
-    String = Rule.new(type: ::String, required: true)
-    Symbol = Rule.new(type: ::Symbol, required: true)
-    Boolean = Rule.new(type: SafeType::Boolean, required: true)
-    Integer = Rule.new(type: ::Integer, required: true)
-    Float = Rule.new(type: ::Float, required: true)
-    Date = Rule.new(type: ::Date, required: true)
-    DateTime = Rule.new(type: ::DateTime, required: true)
-    Time = Rule.new(type: ::Time, required: true)
-  end
-
-  def coerce(input, params)
-    return params.apply(input) if params.class == Rule
-    if params.class == ::Hash
-      result = {}
-      params.each do |key, val|
-        result[key] = coerce(input[key], val)
+  class << self
+    def coerce(input, rule)
+      return rule[input] if rule.is_a?(SafeType::Rule)
+      if rule.class == ::Hash
+        result = {}
+        rule.each do |key, val|
+          result[key] = coerce(input[key], val)
+        end
+        return result
       end
-      return result
-    end
-    if params.class == ::Array
-      return [] if input.nil?
-      result = Array.new(input.length)
-      i = 0
-      while i < input.length
-        result[i] = coerce(input[i], params[i % params.length])
-        i += 1
+      if rule.class == ::Array
+        return [] if input.nil?
+        result = ::Array.new(input.length)
+        i = 0
+        while i < input.length
+          result[i] = coerce(input[i], rule[i % rule.length])
+          i += 1
+        end
+        return result
       end
-      return result
+      raise SafeType::InvalidRuleError
     end
-    raise ArgumentError, "invalid coercion rule"
-  end
 
-  def coerce!(input, params)
-    if params.class == ::Hash
-      params.each do |key, val|
-        if val.class == ::Hash
-          coerce!(input[key], val)
-        else
-          input[key] = coerce(input[key], val)
+    def coerce!(input, rule)
+      if rule.class == ::Hash
+        rule.each do |key, val|
+          if val.class == ::Hash
+            coerce!(input[key], val)
+          else
+            input[key] = coerce(input[key], val)
+          end
         end
+        return nil
       end
-      return nil
-    end
-    if params.class == ::Array
-      i = 0
-      while i < input.length
-        input[i] = coerce(input[i], params[i % params.length])
-        i += 1
+      if rule.class == ::Array
+        i = 0
+        while i < input.length
+          input[i] = coerce(input[i], rule[i % rule.length])
+          i += 1
+        end
+        return nil
       end
-      return nil
+      raise SafeType::InvalidRuleError
     end
-    raise ArgumentError, "invalid coercion rule"
-  end
-
-  class << self
-    include SafeType
   end
 end
-
-class TrueClass; include SafeType::Boolean; end
-class FalseClass; include SafeType::Boolean; end
-class Hash; include SafeType::HashHelper; end

data/lib/safe_type/converter.rb

@@ -0,0 +1,64 @@
+require 'date'
+require 'time'
+
+module SafeType
+  class Converter
+    @@TRUE_VALUES = %w[on On ON t true True TRUE T y yes Yes YES Y].freeze
+    @@FALSE_VALUES = %w[off Off OFF f false False FALSE F n no No NO N].freeze
+
+    def self.to_true(input)
+      true if @@TRUE_VALUES.include?(input.to_s)
+    end
+
+    def self.to_false(input)
+      false if @@FALSE_VALUES.include?(input.to_s)
+    end
+
+    def self.to_bool(input)
+      return true unless self.to_true(input).nil?
+      return false unless self.to_false(input).nil?
+      raise TypeError
+    end
+
+    def self.to_int(input)
+      if input.is_a?(::String)
+        Integer(input, base=10)
+      else
+        Integer(input)
+      end
+    end
+
+    def self.to_float(input)
+      Float(input)
+    end
+
+    def self.to_date(input)
+      ::Date.parse(input)
+    end
+
+    def self.to_date_time(input)
+      ::DateTime.parse(input)
+    end
+
+    def self.to_time(input)
+      ::Time.parse(input)
+    end
+
+    def self.to_type(input, type)
+      return input if input.is_a?(type)
+      return input.safe_type if input.respond_to?(:safe_type)
+      return input.to_s if type == ::String
+      return input.to_sym if type == ::Symbol
+      return self.to_true(input) if type == ::TrueClass
+      return self.to_false(input) if type == ::FalseClass
+      return self.to_bool(input) if type == SafeType::BooleanMixin
+      return self.to_int(input) if type == ::Integer
+      return self.to_float(input) if type == ::Float
+      return self.to_date(input) if type == ::Date
+      return self.to_date_time(input) if type == ::DateTime
+      return self.to_time(input) if type == ::Time
+      return type.try_convert(input) if type.respond_to?(:try_convert)
+      return type.new(input) if type.respond_to?(:new)
+    end
+  end
+end

data/lib/safe_type/errors.rb

@@ -0,0 +1,27 @@
+module SafeType
+  class Error < StandardError; end
+
+  class CoercionError < Error
+    def initialize(message="unable to transform into the requested type")
+      super
+    end
+  end
+
+  class ValidationError < Error
+    def initialize(message="failed to validate")
+      super
+    end
+  end
+
+  class EmptyValueError < Error
+    def initialize(message="the value should not be empty")
+      super
+    end
+  end
+
+  class InvalidRuleError < ArgumentError
+    def initialize(message="invalid coercion rule")
+      super
+    end
+  end
+end

data/lib/safe_type/mixin/boolean.rb

@@ -0,0 +1,12 @@
+module SafeType
+  module BooleanMixin
+  end
+end
+
+class TrueClass
+  include SafeType::BooleanMixin
+end
+
+class FalseClass
+  include SafeType::BooleanMixin
+end

data/lib/safe_type/mixin/hash.rb

@@ -0,0 +1,14 @@
+module SafeType
+  module HashMixin
+    def stringify_keys
+      ::Hash[self.map{ |key, val| [key.to_s, val] }]
+    end
+    def symbolize_keys
+      ::Hash[self.map{ |key, val| [key.to_sym, val] }]
+    end
+  end
+end
+
+class Hash
+  include SafeType::HashMixin
+end

data/lib/safe_type/primitive/boolean.rb

@@ -0,0 +1,13 @@
+require 'safe_type/mixin/boolean'
+
+module SafeType
+  class Boolean < Rule
+    def initialize(type: ::SafeType::BooleanMixin, **args)
+      super
+    end
+
+    def self.default(value=false)
+      new(default: value)
+    end
+  end
+end

data/lib/safe_type/primitive/date.rb

@@ -0,0 +1,31 @@
+module SafeType
+  class Date < Rule
+    def initialize(type: ::Date, from: nil, to: nil, **args)
+      @from = from
+      @to = to
+      super
+    end
+
+    def validate(input)
+      return false unless @from.nil? || input >= @from
+      return false unless @to.nil? || input <= @to
+      super
+    end
+
+    def self.default(value=nil, from: nil, to: nil)
+      new(
+        default: value,
+        from: from,
+        to: to
+      )
+    end
+
+    def self.strict(from: nil, to: nil)
+      new(
+        required: true,
+        from: from,
+        to: to
+      )
+    end
+  end
+end

data/lib/safe_type/primitive/date_time.rb

@@ -0,0 +1,31 @@
+module SafeType
+  class DateTime < Rule
+    def initialize(type: ::DateTime, from: nil, to: nil, **args)
+      @from = from
+      @to = to
+      super
+    end
+
+    def validate(input)
+      return false unless @from.nil? || input >= @from
+      return false unless @to.nil? || input <= @to
+      super
+    end
+
+    def self.default(value=nil, from: nil, to: nil)
+      new(
+        default: value,
+        from: from,
+        to: to
+      )
+    end
+
+    def self.strict(from: nil, to: nil)
+      new(
+        required: true,
+        from: from,
+        to: to
+      )
+    end
+  end
+end

data/lib/safe_type/primitive/float.rb

@@ -0,0 +1,31 @@
+module SafeType
+  class Float < Rule
+    def initialize(type: ::Float, min: nil, max: nil, **args)
+      @min = min
+      @max = max
+      super
+    end
+
+    def validate(input)
+      return false unless @min.nil? || input >= @min
+      return false unless @max.nil? || input <= @max
+      super
+    end
+
+    def self.default(value=0.0, min: nil, max: nil)
+      new(
+        default: value,
+        min: min,
+        max: max
+      )
+    end
+
+    def self.strict(min: nil, max: nil)
+      new(
+        required: true,
+        min: min,
+        max: max
+      )
+    end
+  end
+end

data/lib/safe_type/primitive/integer.rb

@@ -0,0 +1,31 @@
+module SafeType
+  class Integer < Rule
+    def initialize(type: ::Integer, min: nil, max: nil, **args)
+      @min = min
+      @max = max
+      super
+    end
+
+    def validate(input)
+      return false unless @min.nil? || input >= @min
+      return false unless @max.nil? || input <= @max
+      super
+    end
+
+    def self.default(value=0, min: nil, max: nil)
+      new(
+        default: value,
+        min: min,
+        max: max
+      )
+    end
+
+    def self.strict(min: nil, max: nil)
+      new(
+        required: true,
+        min: min,
+        max: max
+      )
+    end
+  end
+end

data/lib/safe_type/primitive/string.rb

@@ -0,0 +1,36 @@
+module SafeType
+  class String < Rule
+    def initialize(type: ::String, min_length: nil, max_length: nil, **args)
+      @min_length = min_length
+      @max_length = max_length
+      super
+    end
+
+    def validate(input)
+      return false unless @min_length.nil? || input.length >= @min_length
+      return false unless @max_length.nil? || input.length <= @max_length
+      super
+    end
+
+    def after(input)
+      return nil if input.length == 0
+      super
+    end
+
+    def self.default(value="", min_length: nil, max_length: nil)
+      new(
+        default: value,
+        min_length: min_length,
+        max_length: max_length
+      )
+    end
+
+    def self.strict(min_length: nil, max_length: nil)
+      new(
+        required: true,
+        min_length: min_length,
+        max_length: max_length
+      )
+    end
+  end
+end

data/lib/safe_type/primitive/symbol.rb

@@ -0,0 +1,36 @@
+module SafeType
+  class Symbol < Rule
+    def initialize(type: ::Symbol, min_length: nil, max_length: nil, **args)
+      @min_length = min_length
+      @max_length = max_length
+      super
+    end
+
+    def validate(input)
+      return false unless @min_length.nil? || input.length >= @min_length
+      return false unless @max_length.nil? || input.length <= @max_length
+      super
+    end
+
+    def after(input)
+      return nil if input.length == 0
+      super
+    end
+
+    def self.default(value=nil, min_length: nil, max_length: nil)
+      new(
+        default: value,
+        min_length: min_length,
+        max_length: max_length
+      )
+    end
+
+    def self.strict(min_length: nil, max_length: nil)
+      new(
+        required: true,
+        min_length: min_length,
+        max_length: max_length
+      )
+    end
+  end
+end

data/lib/safe_type/primitive/time.rb

@@ -0,0 +1,31 @@
+module SafeType
+  class Time < Rule
+    def initialize(type: ::Time, from: nil, to: nil, **args)
+      @from = from
+      @to = to
+      super
+    end
+
+    def validate(input)
+      return false unless @from.nil? || input >= @from
+      return false unless @to.nil? || input <= @to
+      super
+    end
+
+    def self.default(value=nil, from: nil, to: nil)
+      new(
+        default: value,
+        from: from,
+        to: to
+      )
+    end
+
+    def self.strict(from: nil, to: nil)
+      new(
+        required: true,
+        from: from,
+        to: to
+      )
+    end
+  end
+end

data/lib/safe_type/rule.rb

@@ -0,0 +1,58 @@
+require 'safe_type/converter'
+require 'safe_type/errors'
+
+module SafeType
+  class Rule
+    def initialize(type:, default: nil, required: false, **args)
+      unless type.class == ::Class || type.class == ::Module
+        raise ArgumentError.new("type has to a class or module")
+      end
+      @type = type
+      @required = required
+      @default = default
+    end
+
+    def validate(input)
+      true
+    end
+
+    def before(input)
+      input
+    end
+
+    def after(input)
+      input
+    end
+
+    def handle_exceptions(e)
+      raise SafeType::CoercionError
+    end
+
+    def self.[](input)
+      default[input]
+    end
+
+    def self.default
+      new
+    end
+
+    def self.strict
+      new(required: true)
+    end
+
+    def [](input)
+      raise SafeType::EmptyValueError if input.nil? && @required
+      input = before(input)
+      input = Converter.to_type(input, @type)
+      raise SafeType::ValidationError unless validate(input)
+      result = after(input)
+      raise SafeType::EmptyValueError if result.nil? && @required
+      return @default if result.nil?
+      raise SafeType::CoercionError unless result.is_a?(@type)
+      result
+    rescue TypeError, ArgumentError, NoMethodError => e
+      return @default if input.nil? && !@required
+      handle_exceptions(e)
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: safe_type
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Donald Dong
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-06-08 00:00:00.000000000 Z
+date: 2018-06-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -46,6 +46,19 @@ extra_rdoc_files: []
 files:
 - README.md
 - lib/safe_type.rb
+- lib/safe_type/converter.rb
+- lib/safe_type/errors.rb
+- lib/safe_type/mixin/boolean.rb
+- lib/safe_type/mixin/hash.rb
+- lib/safe_type/primitive/boolean.rb
+- lib/safe_type/primitive/date.rb
+- lib/safe_type/primitive/date_time.rb
+- lib/safe_type/primitive/float.rb
+- lib/safe_type/primitive/integer.rb
+- lib/safe_type/primitive/string.rb
+- lib/safe_type/primitive/symbol.rb
+- lib/safe_type/primitive/time.rb
+- lib/safe_type/rule.rb
 homepage: https://github.com/chanzuckerberg/safe_type
 licenses:
 - MIT