rasti-types 1.0.0

data/lib/rasti/types/float.rb

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

data/lib/rasti/types/hash.rb

@@ -0,0 +1,54 @@
+module Rasti
+  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)
+        result = {}
+        errors = {}
+
+        value.each do |k,v|
+          begin
+            result[key_type.cast k] = value_type.cast v
+
+          rescue CompoundError => ex
+            ex.errors.each do |key, messages|
+              errors["#{k}.#{key}"] = messages
+            end
+
+          rescue => error
+            errors[k] = [error.message]
+          end
+        end
+
+        raise MultiCastError.new(self, value, errors) unless errors.empty?
+
+        result
+      end
+
+    end
+  end
+end

data/lib/rasti/types/integer.rb

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

data/lib/rasti/types/io.rb

@@ -0,0 +1,21 @@
+module Rasti
+  module Types
+    class IO
+      class << self
+
+        include Castable
+
+        private
+
+        def valid?(value)
+          value.respond_to?(:read) && value.respond_to?(:write)
+        end
+
+        def transform(value)
+          value
+        end
+
+      end
+    end
+  end
+end

data/lib/rasti/types/model.rb

@@ -0,0 +1,34 @@
+module Rasti
+  module Types
+    class Model
+
+      include Castable
+
+      attr_reader :model
+
+      def self.[](model)
+        new(model)
+      end
+
+      def to_s
+        "#{self.class}[#{model}]"
+      end
+      alias_method :inspect, :to_s
+
+      private
+
+      def initialize(model)
+        @model = model
+      end
+
+      def valid?(value)
+        value.is_a? ::Hash
+      end
+
+      def transform(value)
+        model.new value
+      end
+
+    end
+  end
+end

data/lib/rasti/types/regexp.rb

@@ -0,0 +1,21 @@
+module Rasti
+  module Types
+    class Regexp
+      class << self
+
+        include Castable
+
+        private
+
+        def valid?(value)
+          value.is_a?(::Regexp) || value.is_a?(::String)
+        end
+
+        def transform(value)
+          value.is_a?(::Regexp) ? value.source : ::Regexp.compile(value).source
+        end
+
+      end
+    end
+  end
+end

data/lib/rasti/types/string.rb

@@ -0,0 +1,38 @@
+module Rasti
+  module Types
+    class String
+      class << self
+
+        include Castable
+
+        def [](format)
+          Class.new(self) do
+            @format = format.is_a?(::String) ? ::Regexp.new(format) : format
+          end
+        end
+
+        def to_s
+          name || "#{superclass.name}[#{format.inspect}]"
+        end
+        alias_method :inspect, :to_s
+
+        private
+
+        attr_reader :format
+
+        def valid?(value)
+          !value.nil? && value.respond_to?(:to_s) && valid_format?(value)
+        end
+
+        def valid_format?(value)
+          format.nil? || !value.to_s.match(format).nil?
+        end
+
+        def transform(value)
+          value.to_s
+        end
+
+      end
+    end
+  end
+end

data/lib/rasti/types/symbol.rb

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

data/lib/rasti/types/time.rb

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

data/lib/rasti/types/uuid.rb

@@ -0,0 +1,5 @@
+module Rasti
+  module Types
+    UUID = String[/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}+$/]
+  end
+end

data/lib/rasti/types/version.rb

@@ -0,0 +1,5 @@
+module Rasti
+  module Types
+    VERSION = '1.0.0'
+  end
+end

data/rasti-types.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rasti/types/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'rasti-types'
+  spec.version       = Rasti::Types::VERSION
+  spec.authors       = ['Gabriel Naiman']
+  spec.email         = ['gabynaiman@gmail.com']
+  spec.summary       = 'Type casting'
+  spec.description   = 'Type casting'
+  spec.homepage      = 'https://github.com/gabynaiman/rasti-types'
+  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 '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'
+end

data/spec/array_spec.rb

@@ -0,0 +1,55 @@
+require 'minitest_helper'
+
+describe Rasti::Types::Array do
+
+  VALID_ARRAY = [1, '2', Time.now]
+  INVALID_ARRAY = [nil, 1, 'text', :symbol, {a: 1, b: 2}, Object.new]
+
+  it "#{VALID_ARRAY.inspect} -> #{VALID_ARRAY.map(&:to_i)}" do
+    Rasti::Types::Array[Rasti::Types::Integer].cast(VALID_ARRAY).must_equal VALID_ARRAY.map(&:to_i)
+  end
+
+  it "#{VALID_ARRAY.inspect} -> #{VALID_ARRAY.map(&:to_s)}" do
+    Rasti::Types::Array[Rasti::Types::String].cast(VALID_ARRAY).must_equal VALID_ARRAY.map(&:to_s)
+  end
+
+  INVALID_ARRAY.each do |value|
+    it "#{value.inspect} -> CastError" do
+      error = proc { Rasti::Types::Array[Rasti::Types::String].cast(value) }.must_raise Rasti::Types::CastError
+      error.message.must_equal "Invalid cast: #{as_string(value)} -> Rasti::Types::Array[Rasti::Types::String]"
+    end
+  end
+
+  describe 'Multi cast errors' do
+
+    it 'Array of integers' do
+      array = [1, 2 , 'a', 3, 'c', 4, nil]
+
+      error = proc { Rasti::Types::Array[Rasti::Types::Integer].cast(array) }.must_raise Rasti::Types::MultiCastError
+
+      error.errors.must_equal 3 => ["Invalid cast: 'a' -> Rasti::Types::Integer"],
+                              5 => ["Invalid cast: 'c' -> Rasti::Types::Integer"],
+                              7 => ["Invalid cast: nil -> Rasti::Types::Integer"]
+
+      error.message.must_equal "Cast errors:\n- 3: [\"Invalid cast: 'a' -> Rasti::Types::Integer\"]\n- 5: [\"Invalid cast: 'c' -> Rasti::Types::Integer\"]\n- 7: [\"Invalid cast: nil -> Rasti::Types::Integer\"]"
+    end
+
+    it 'Array of models' do
+      array = [
+        {x: 1, y: 2},
+        {y: 2},
+        {x: 1},
+        {x: 3, y: 4}
+      ]
+
+      error = proc { Rasti::Types::Array[Rasti::Types::Model[Point]].cast(array) }.must_raise Rasti::Types::MultiCastError
+
+      error.errors.must_equal '2.x' => ['not present'],
+                              '3.y' => ['not present']
+
+      error.message.must_equal "Cast errors:\n- 2.x: [\"not present\"]\n- 3.y: [\"not present\"]"
+    end
+
+  end
+
+end

data/spec/boolean_spec.rb

@@ -0,0 +1,24 @@
+require 'minitest_helper'
+
+describe Rasti::Types::Boolean do
+
+  [true, 'true', 'True', 'TRUE', 'T'].each do |value|
+    it "#{value.inspect} -> true" do
+      Rasti::Types::Boolean.cast(value).must_equal true
+    end
+  end
+
+  [false, 'false', 'False', 'FALSE', 'F'].each do |value|
+    it "#{value.inspect} -> false" do
+      Rasti::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::Types::Boolean.cast(value) }.must_raise Rasti::Types::CastError
+      error.message.must_equal "Invalid cast: #{as_string(value)} -> Rasti::Types::Boolean"
+    end
+  end
+
+end

data/spec/coverage_helper.rb

@@ -0,0 +1,5 @@
+require 'simplecov'
+require 'coveralls'
+
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new [SimpleCov::Formatter::HTMLFormatter, Coveralls::SimpleCov::Formatter]
+SimpleCov.start

data/spec/enum_spec.rb

@@ -0,0 +1,28 @@
+require 'minitest_helper'
+
+describe Rasti::Types::Enum do
+
+  enum = Rasti::Types::Enum[:a,:b,:c]
+
+  [:a, 'b', "c"].each do |value|
+    it "#{value.inspect} -> #{enum}" do
+      Rasti::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::Types::Enum[:a,:b,:c].cast(value) }.must_raise Rasti::Types::CastError
+      error.message.must_equal "Invalid cast: #{as_string(value)} -> Rasti::Types::Enum[\"a\", \"b\", \"c\"]"
+    end
+  end
+
+  it 'Constants' do
+    enum = Rasti::Types::Enum[:first_value, 'SecondValue', 'THIRD_VALUE']
+
+    enum.first_value.must_equal 'first_value'
+    enum.second_value.must_equal 'SecondValue'
+    enum.third_value.must_equal 'THIRD_VALUE'
+  end
+
+end