typero 0.2.7 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5d62a6bb35901d4b3b8a3734f9eb642facd83ea7
-  data.tar.gz: 33d5c380b533fee0bbf1ce7d7fe5d46c57f0ff17
+  metadata.gz: '06869371b2f8a0fadb0c88f51a8a011aee2619a3'
+  data.tar.gz: 3593d80591d5a061fa02be6ef16816b3ee05c71d
 SHA512:
-  metadata.gz: 6b51d247bedb7cdde07887f0411944f461ef63b521bccad0b8c09efc541575eb069511661d1fd25c996aa2eae3efecb3092d77f122cb2054417e59be112dbcb2
-  data.tar.gz: 3174416a39d5fcf514a181011732ba4f913c4d68d14017e126be4fcf7ab94593a59396bfbbf4e3f8237437da555ff81ebd74309bbc931b73a769c0d2beda7ef8
+  metadata.gz: 7e4720817d8fae4a96d5b65ac2d68d39aea79609a0e7be7f2828b137318ab0059a68661994d5551dbbc2fa9c5c21a8c33ec3902c8a99612007b15ceec8d7f662
+  data.tar.gz: 3551cfde3e9da75ddf74cc5c6deaa98476a37dba821644c8613d35fd2ecaede68270ff00f265731b2725a10f55c289bff7a99334a810b1c67dcee06a0202aa87

data/.version

@@ -0,0 +1 @@
+0.3.0

data/lib/typero.rb

@@ -1,91 +1,135 @@
-require 'fast_blank'
+# rules = Typero.new do
+#   set :name, String, req: true
+#   set :email, :email, req: true
+#   set :skills, [:email], min: 2
+# end
+#
+# errors = rules.validate @object
+# rules.valid?
+# rules.validate(@object) { |errors| ... }
+
+class Typero
+  attr_reader :rules
+
+  VERSION = File.read File.expand_path '../.version', File.dirname(__FILE__)
+
+  class << self
+    # validate single value in type
+    def validate value, type, opts={}
+      field = type.to_s.tableize.singularize.to_sym
+
+      # we need to have pointer to hash, so value can be changed (coerced) if needed
+      h = { field => value }
+
+      rule = new
+      rule.set field, type, opts
+
+      if error = rule.validate(h)[field]
+        block_given? ? yield(error) : raise(TypeError.new(error))
+      end
 
-require_relative './typero/instance'
-require_relative './typero/schema'
-require_relative './typero/type'
-require_relative './typero/hash'
+      h[field]
+    end
 
-Dir["#{File.dirname(__FILE__)}/typero/type/*.rb"].each{ |f| load f }
+    def cache
+      @@cache ||= {}
+    end
+  end
 
-# attribute :url, :url
-# attribute :name, req:'Link name is required'
-# attribute :tags, Array[:label]
-# attribute :bucket_id, Integer, req:'Bucket is not assigned'
-# attribute :kind, String, allow:[:doc, :img, :vid, :lnk, :art], default:'lnk'
-# attribute :email, :email, req:true, uniq:"Email is allready registred", protected:"You are not allowed to change the email"
+  ###
 
-# Typero.validate('dux@dux.net', :email)
+  # accepts dsl block to
+  def initialize hash={}, &block
+    @rules = {}
+    hash.each { |k, v| set(k, v) }
+    instance_exec &block if block
+  end
 
-module Typero
-  extend self
+  # coerce opts values
+  def parse_option opts
+    opts[:type] ||= 'string'
+    opts[:req] = opts.delete(:required) unless opts[:required].nil?
 
-  @opts ||= {}
+    if opts[:type].is_a?(Array)
+       opts[:array_type] = opts[:type][0] if opts[:type][0]
+       opts[:type] = 'array'
+    end
 
-  def opts
-    @opts
-  end
+    opts[:type] = opts[:type].to_s.downcase
 
-  # called to define instance variable in class
-  # Typero.define_instance(self, :email, { :type=>:email })
-  def define_instance(klass, name, opts={})
-    type = opts[:type]
-    opts[:name] = name
+    allowed_names = [:req, :uniq, :protected, :type, :min, :max, :array_type, :default, :downcase, :desc]
+    opts.keys.each do |key|
+      raise ArgumentError.new('%s is not allowed as typero option' % key) unless allowed_names.index(key)
+    end
 
-    type_klass = "Typero::#{type.to_s.classify}Type".constantize
-    @opts[klass.to_s] ||= {}
-    @opts[klass.to_s][name] = type_klass.new(opts).freeze
+    opts
+  end
 
-    klass.class_eval %[
-      def #{name}
-        Typero.opts['#{klass}'][:#{name}].get_value(self)
-      end
+  # used in dsl to define value
+  def set field, type=String, opts={}
+    opts = type.is_a?(Hash) ? type : opts.merge(type: type)
 
-      def #{name}=(value=nil)
-        Typero.opts['#{klass}'][:#{name}].set_value(self, value)
-      end
-    ]
+    @rules[field] = parse_option opts
   end
 
-  def last_error
-    Thread.current[:validate_last_error]
+  def safe_type type
+    type.to_s.gsub(/[^\w]/,'').classify
   end
 
-  # Typero.validate('duxdux.net', :email) # raise erorr
-  # Typero.validate('duxdux.net', :email) { |msg| error(msg) } # capture
-  def validate!(value, type, opts={}, &block)
-    type_klass = "Typero::#{type.to_s.classify}Type".constantize
-    type_klass.new(opts).validate(value)
-    true
-  rescue TypeError
-    if block
-      block.call($!.message)
-      return false
+  # adds error to array or prefixes with field name
+  def add_error field, msg
+    if @errors[field]
+      @errors[field] += ', %s' % msg
+    else
+      field_name = field.to_s.sub(/_id$/,'').humanize
+      @errors[field] = '%s %s' % [field_name, msg]
     end
-    raise(TypeError, $!.message)
   end
 
-  # Typero.validate('duxdux.net', :email) -> false
-  def validate(*args)
-    validate!(*args)
-    true
-  rescue TypeError
-    false
-  end
+  # validates any instance object or object with hash variable interface
+  # it also coarces values
+  def validate instance
+    @errors = {}
+
+    @rules.each do |field, opts|
+      # set value to default if value is blank and default given
+      instance[field] = opts[:default] if opts[:default] && instance[field].blank?
+
+      # get field value
+      value = instance[field]
+
+      if value.present?
+        klass = 'Typero::%sType' % safe_type(opts[:type])
+        check = klass.constantize.new value, opts
+        check.value = check.default if check.value.nil?
+
+        unless check.value.nil?
+          begin
+            check.set
+            check.validate
+            instance[field] = check.value
+          rescue TypeError => e
+            add_error field, e.message
+          end
+        end
+      elsif opts[:req]
+        add_error field, 'is required' if opts[:req].class == TrueClass
+      end
+    end
 
-  # Typero.quick_set('[invalid-to-fix]', :label)
-  def quick_set(value, type, opts={})
-    type_klass = "Typero::#{type.to_s.classify}Type".constantize
-    type_inst  = type_klass.new(opts)
-    type_inst.set(value)
+    if @errors.keys.length > 0 && block_given?
+      @errors.each { |k,v| yield(k, v) }
+    end
+
+    @errors
   end
 
-  # Typero.validate_opts params, :ttl, :password
-  # only :ttl, :password and allowed in hash
-  def validate_opts(hash, *args)
-    for key in (hash || {}).keys
-      raise TypeError, "Key :#{key} is not allowed in hash" unless args.index(key)
-    end
-    hash
+  def valid? instance
+    errors = validate instance
+    errors.keys.length == 0
   end
 end
 
+require_relative 'typero/type'
+
+Dir['%s/typero/type/*.rb' % File.dirname(__FILE__)].each { |file| require file }

data/lib/typero/type.rb

@@ -1,104 +1,27 @@
-# str = Typero::StringType.new(req:true, default:'Miki')
-# str.set_value('Dino')
-# puts str.get_value
+class Typero::Type
+  attr_accessor :opts
+  attr_accessor :value
 
-# str = Typero::EmailType.new()
-# str.set_value('dux|at|dux.net') -> raises eror
-module Typero
-  class Type
-    attr_accessor :opts
-
-    ### SAFE TO OVERLOAD: START
-
-    # if value is not blank, it is sent to set method
-    def set(value)
-      value
-    end
-
-    # sometimes we want to coarce values on get
-    # by default just copy
-    def get(list)
-      list
-    end
-
-    # if value is blank?, trigger default
-    # for example set it to false for boolean type and [] for array type
-    def default
-      nil
-    end
-
-    # default validation for any type
-    def validate(what)
-      true
-    end
-
-    ### SAFE TO OVERLOAD: END
-
-    # set options
-    def initialize(opts={})
-      @type = self.class.to_s.split('::')[1].sub('Type','').downcase.to_sym
-      @opts = opts
-      @name = opts.delete(:name)
-    end
-
-    def check_type(type)
-      type_klass = "Typero::#{type.to_s.classify}Type"
-      (type_klass.constantize rescue false) ? true : false
-    end
-
-    def get_value(instance)
-      # get current var value
-      value = instance.respond_to?('[]') ? instance[@name] : instance.instance_variable_get("@#{@name}")
-      if value.nil?
-        if @opts[:default]
-          @opts[:default].class.to_s == 'Proc' ? @opts[:default].call(instance) : @opts[:default]
-        else
-          return default
-        end
-      else
-        get(value)
-      end
-    end
-
-    def set_value(instance, value=nil)
-      if !value.blank?
-        # for user emails, once defined cant be overitten
-        if @opts[:protected] && get_value(instance) && get_value(instance) != value
-          raise TypeError, @opts[:protected].class == TrueClass ? "#{@name.capitalize} is allready defined and can't be overwritten." : @opts[:protected]
-        end
+  def initialize(value, opts)
+    @value = value
+    @opts  = opts
+  end
 
-        value = set(value)
+  # default validation for any type
+  def validate(what)
+    true
+  end
 
-        # search for unique fields on set, say for email
-        # so it is not checked on save, it is checked on set
-        if @opts[:uniq]
-          not_unique = false
-          if instance.respond_to?(:is_unique_field?)
-            not_unique = !instance.is_unique_field?(@name, value)
-          else
-            filter = instance.class.select(:id).where("#{@name}=?", value)
-            filter = filter.where('id<>?', instance.id) if instance.id
-            not_unique = true if filter.first
-          end
-          raise TypeError, @opts[:uniq].class == TrueClass ? %[Field #{@name} is uniqe and value "#{value}" allready exists] : @opts[:uniq] if not_unique
-        end
+  def get
+    @value
+  end
 
-        validate(value)
-      elsif @opts[:req]
-        msg = @opts[:req].class == TrueClass ? "is required" : @opts[:req]
-        raise TypeError, msg
-      else
-        value = default
-      end
+  def set
+    @value
+  end
 
-      if instance.respond_to?('[]')
-        # save to hash by default
-        instance[@name] = value
-      else
-        # fallback to instance variable if no hash (plain class, not AR or Sequel)
-        instance.instance_variable_set("@#{@name}", value)
-      end
-    end
+  def default
+    nil
   end
 end
 

data/lib/typero/type/array.rb

@@ -1,36 +1,32 @@
-module Typero
-  class ArrayType < Typero::Type
-    def default
-      []
-    end
+class Typero::ArrayType < Typero::Type
+  def default
+    []
+  end
 
-    def get(value)
-      unless value.class.to_s.index('Array')
-        value = value.to_s.sub(/^\{/,'').sub(/\}$/,'').split(/\s*,\s*/)
-      end
-      value
+  def set
+    unless @value.class.to_s.index('Array')
+      @value = @value.to_s.sub(/^\{/,'').sub(/\}$/,'').split(/\s*,\s*/)
     end
 
-    def set(value)
-      value = get(value)
-      # value = value.to_a unless value.is_array?
+    @value.uniq!
+    @value.compact!
 
-      # force type for all elements of array
-      if type = @opts[:array_type]
-        value.map! { |el|
-          Typero.validate!(el, type)
-          Typero.quick_set(el, type)
+    if type = @opts[:array_type]
+      @value.map! { |el|
+        Typero.validate(el, type) { |msg|
+          raise TypeError.new "'%s' %s (value in list)" % [el, msg]
         }
-      end
-
-      value
+      }
     end
 
-    def validate(list)
-      raise TypeError, "Min array lenght is #{@opts[:min]} elements" if @opts[:min] && @opts[:min] < list.length
-      raise TypeError, "Max array lenght is #{@opts[:max]} elements" if @opts[:max] && @opts[:max] < list.length
-      true
-    end
+    # this converts Sequel::Postgres::PGArray to Array and fixes many problems
+    @value = @value.to_a if @value.class != Array
+  end
+
+  def validate
+    raise TypeError, 'Min array lenght is %s elements' % @opts[:min] if @opts[:min] && @value.length < @opts[:min]
+    raise TypeError, 'Max array lenght is %s elements' % @opts[:max] if @opts[:max] && @value.length > @opts[:max]
+    true
   end
 end
 

data/lib/typero/type/boolean.rb

@@ -1,12 +1,10 @@
-module Typero
-  class BooleanType < Typero::Type
-    def default
-      false
-    end
+class Typero::BooleanType < Typero::Type
+  def default
+    false
+  end
 
-    def set(value)
-      [true, 1, '1', 'true'].index(value) ? true : false
-    end
+  def set
+    @value = [true, 1, '1', 'true', 'on'].include?(@value) ? true : false
   end
 end
 

data/lib/typero/type/email.rb

@@ -1,15 +1,14 @@
-module Typero
-  class EmailType < Typero::Type
-    def set(value)
-      value.downcase.gsub(/\s+/,'+')
-    end
-
-    def validate(value)
-      raise TypeError, 'is not having at least 8 characters' unless value.to_s.length > 7
-      raise TypeError, 'is missing @' unless value.include?('@')
-      raise TypeError, 'is in wrong format' unless value =~ /^[\+\w\-\.]+\@[\w\-\.]+$/i
-      true
-    end
+class Typero::EmailType < Typero::Type
+
+  def set
+    @value = @value.downcase.gsub(/\s+/,'+')
+  end
+
+  def validate
+    raise TypeError, 'is not having at least 8 characters' unless @value.to_s.length > 7
+    raise TypeError, 'is missing @' unless @value.include?('@')
+    raise TypeError, 'is in wrong format' unless @value =~ /^[\+\w\-\.]+\@[\w\-\.]+$/i
   end
+
 end
 

data/lib/typero/type/float.rb

@@ -1,19 +1,13 @@
-module Typero
-  class FloatType < Typero::Type
-    def set(value)
-      value.to_f
-    end
+class Typero::FloatType < Typero::Type
 
-    def get(value)
-      value.to_f
-    end
+  def set
+    @value = @value.to_f
+  end
 
-    def validate(input)
-      value = set(input)
-      raise TypeError, "min lenght is #{@opts[:min]}" if @opts[:min] && value < @opts[:min]
-      raise TypeError, "max lenght is #{@opts[:max]}" if @opts[:max] && value > @opts[:max]
-      true
-    end
+  def validate
+    raise TypeError, "min lenght is #{@opts[:min]}" if @opts[:min] && value < @opts[:min]
+    raise TypeError, "max lenght is #{@opts[:max]}" if @opts[:max] && value > @opts[:max]
   end
+
 end
 

data/lib/typero/type/hash.rb

@@ -1,8 +1,10 @@
-module Typero
-  class HashType < Typero::Type
-    def default
-      {}
-    end
+class Typero::HashType < Typero::Type
+  def default
+    {}
+  end
+
+  def validate
+    raise TypeError, 'Value is not hash type' unless @value.is_a?(Hash)
   end
 end
 

data/lib/typero/type/integer.rb

@@ -1,17 +1,11 @@
-module Typero
-  class IntegerType < Typero::Type
-    def set(value)
-      value.to_i
-    end
-
-    def validate(input)
-      value = set(input)
-
-      raise TypeError, "min lenght is #{@opts[:min]}, you have #{value}" if @opts[:min] && value < @opts[:min]
-      raise TypeError, "max lenght is #{@opts[:max]}, you have #{value}" if @opts[:max] && value > @opts[:max]
+class Typero::IntegerType < Typero::Type
+  def set
+    @value = @value.to_i
+  end
 
-      true
-    end
+  def validate
+    raise TypeError, 'min is %s, got %s' % [@opts[:min], @value] if @opts[:min] && @value < @opts[:min]
+    raise TypeError, 'max is %s, got %s' % [@opts[:max], @value] if @opts[:max] && @value > @opts[:max]
   end
 end
 

data/lib/typero/type/label.rb

@@ -1,13 +1,9 @@
-module Typero
-  class LabelType < Typero::Type
-    def set(value)
-      value.to_s.gsub(/[^\w\-]/,'')[0,30].downcase
-    end
+class Typero::LabelType < Typero::Type
+  def set
+    @value = @value.to_s.gsub(/\s+/,'-').gsub(/[^\w\-]/,'')[0,30].downcase
+  end
 
-    def validate(value)
-      raise TypeError, "Label is having unallowed characters" unless value =~ /^[\w\-]+$/
-      true
-    end
+  def validate
+    raise TypeError, "Label is having unallowed characters" unless @value =~ /^[\w\-]+$/
   end
 end
-

data/lib/typero/type/string.rb

@@ -1,10 +1,12 @@
-module Typero
-  class StringType < Typero::Type
-    def set(value)
-      value = value.to_s
-      value = value.downcase if @opts[:downcase]
-      value
-    end
+class Typero::StringType < Typero::Type
+  def set
+    @value = @value.to_s unless @value.is_a?(String)
+    @value = @value.downcase if @opts[:downcase]
+  end
+
+  def validate
+    raise TypeError, 'min lenght is %s, you have %s' % [@opts[:min], @value.length] if @opts[:min] && @value.length < @opts[:min]
+    raise TypeError, 'max lenght is %s, you have %s' % [@opts[:max], @value.length] if @opts[:max] && @value.length > @opts[:max]
   end
 end
 

data/lib/typero/type/url.rb

@@ -1,9 +1,10 @@
-module Typero
-  class UrlType < Typero::Type
-    def validate(value)
-      raise TypeError, 'URL is not starting with http' unless value =~ /^https?:\/\/./
-      true
-    end
+class Typero::UrlType < Typero::Type
+  def set
+    @value = 'http://%s' % @value unless @value.include?('://')
+  end
+
+  def validate
+    raise TypeError, 'URL is not starting with http' unless @value =~ /^https?:\/\/./
   end
 end
 

data/lib/typero/type/utf_label.rb

@@ -0,0 +1,11 @@
+class Typero::UtfLabelType < Typero::Type
+  MASK = /[\/\\\[\]'"]/
+
+  def set
+    @value = @value.to_s.gsub(/\s+/,'-').gsub(MASK,'')[0,50].downcase
+  end
+
+  def validate
+    raise TypeError, "Label is having unallowed characters" if @value =~ MASK
+  end
+end

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: typero
 version: !ruby/object:Gem::Version
-  version: 0.2.7
+  version: 0.3.0
 platform: ruby
 authors:
 - Dino Reic
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-01-09 00:00:00.000000000 Z
+date: 2017-08-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fast_blank
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1'
 description: Simple and fast ruby type system. Enforce types as Array, Email, Boolean
   for ruby class instances
 email: reic.dino@gmail.com
@@ -31,10 +31,8 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- "./.version"
 - "./lib/typero.rb"
-- "./lib/typero/hash.rb"
-- "./lib/typero/instance.rb"
-- "./lib/typero/schema.rb"
 - "./lib/typero/type.rb"
 - "./lib/typero/type/array.rb"
 - "./lib/typero/type/boolean.rb"
@@ -45,7 +43,7 @@ files:
 - "./lib/typero/type/label.rb"
 - "./lib/typero/type/string.rb"
 - "./lib/typero/type/url.rb"
-- "./lib/typero/version.rb"
+- "./lib/typero/type/utf_label.rb"
 homepage: https://github.com/dux/typero
 licenses:
 - MIT
@@ -66,7 +64,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.8
+rubygems_version: 2.6.10
 signing_key: 
 specification_version: 4
 summary: Ruby type system

data/lib/typero/hash.rb

@@ -1,16 +0,0 @@
-module Typero
-
-  # adds hash interface to models
-  module Hash
-    def [](k)
-      @attrs ||= {}
-      @attrs[k]
-    end
-
-    def []=(k,v)
-      @attrs ||= {}
-      @attrs[k] = v
-    end
-  end
-
-end

data/lib/typero/instance.rb

@@ -1,52 +0,0 @@
-module Typero
-  module Instance
-    def self.included(base)
-      def base.attribute(name, *args)
-        if !args[0]
-          opts = { type: :string }
-        elsif args[0].class.to_s == 'Hash'
-          if args[0].keys.length == 0
-            opts = { type: :hash }
-          else
-            type = args[0][:type] || :string
-            opts = args[0].merge( type: type )
-          end
-        elsif args[1]
-          opts = args[1]
-          opts[:type] = args[0]
-        else
-          opts = { type: args[0] }
-        end
-
-        if opts[:type].class.to_s == 'Array' && opts[:type][0] # Array[:email] -> array of emails
-          opts[:array_type] = opts[:type][0].to_s.downcase.to_sym
-          opts[:type] = :array
-        end
-
-        opts[:type]  = opts[:type].to_s.downcase.to_sym
-        opts[:type]  = :array if opts[:type] == :[]
-        opts[:req]   = "#{name.to_s.humanize.capitalize} is required" if opts[:req].class == TrueClass
-
-        Typero.define_instance(self, name, opts)
-      end
-    end
-
-    # def attributes=(opts)
-    #   for k,v in opts
-    #     send("#{k}=", v)
-    #   end
-    # end
-
-    def attribute_errors
-      # hash = InstanceAttributes.opts[self.class.to_s]
-      klass = self.class.to_s
-      opts = Typero.opts[klass]
-      return [] unless opts
-      errors = []
-      for k, v in opts
-        errors.push [k, v.opts[:req]] if v.opts[:req] && self[k].blank?
-      end
-      errors
-    end
-  end
-end

data/lib/typero/schema.rb

@@ -1,71 +0,0 @@
-# validates hash against the schema
-# good if you can create validate objects and check against for function parameters
-# use whenever you want to check hash values of variables
-# in Lux FW, used in api cell
-
-# Typero::Schema.load_schema(email:{ req: true, type: :email}, age: { type: Integer, req: false })
-module Typero
-  class Schema
-    class << self
-      # loads schema from hash and creates schema object
-      def load_schema(hash)
-        validate = new
-        for k,v in hash
-          validate.set(k,v)
-        end
-        validate
-      end
-    end
-
-    ###
-
-    def initialize
-      @check = {}
-    end
-
-    # set field values to check
-    # :age, Integer, { min:18, max:110 }
-    # :email, :email, { req:false }
-    def set(field, opts={}, &block)
-      opts[:req] ||= true unless opts[:req].class == FalseClass
-      opts[:func] = block if block_given?
-      opts[:type] ||= String
-      @check[field] = opts
-    end
-
-    # check agains hash of values { email:'dux@net.hr', age:'40' }
-    def check(hash)
-      errors = {}
-      for field in @check.keys
-        value = hash[field]
-        check_hash = @check[field]
-        type = check_hash[:type]
-
-        if value.blank? && check_hash[:req].class != FalseClass
-          errors[field] = check_hash[:req].kind_of?(String) ? check_hash[:req] : "#{field.to_s.capitalize} is required"
-          next
-        end
-
-        if check_hash[:func]
-          begin
-            check_hash[:func].call(value.to_s)
-          rescue
-            errors[field] = $!.message
-          end
-        else
-          Typero.validate!(value, type, check_hash) { |msg|
-            errors[field] = "#{field.to_s.capitalize}: #{msg}"
-          }
-
-          # coerce value
-          hash[field] = Typero.quick_set(value, type) if value.present?
-        end
-      end
-      errors.keys.length > 0  ? errors : nil
-    end
-
-    def keys
-      @check.keys
-    end
-  end
-end

data/lib/typero/version.rb

@@ -1,4 +0,0 @@
-module Typero
-  # VERSION = File.read(File.dirname(__FILE__)+'/version.txt').gsub(/\s/,'').freeze
-  VERSION = '0.2.7'
-end