trafaret 1.1.0 → 1.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bc7865262c4ddd22e53d71b22cb53aa70b53f403
-  data.tar.gz: f5fe1c37f11b712d536e3fdb6de0c0189f0fa31e
+  metadata.gz: d3da287d80b08ce05b13b14cc3a273319a73dd20
+  data.tar.gz: 8dbec245e7f84988b0c6686182b7039ac4fb5e72
 SHA512:
-  metadata.gz: d3021461ace4f7c6df04852525cdd60a8fb161f1915d641b6493cc3da3253e4fba8d21e6e3271e9e5cdbfcce4cb353f99c71b7c269366950100116e292063b1d
-  data.tar.gz: d9cca1a58733a9d30c4b8917e0e0f6b01666f3f8b82611957a727b365949992b59510c17e149725c64a6d84eb86a7fcadd315129ceda85bb3aa77a9bd0ecf75e
+  metadata.gz: dece3132f430f9f0bf9a7d70fc903033bbacd78566bf7eb4465ea3fe4fdc8aeef89d46888102810e8a865810837c08ff71e58a91857e8e481edae9f33249f722
+  data.tar.gz: 2d639254921bca95796de8d776b54bc713d637a5076b85643a5eb70c81442a8104c86894c35e29ac5470b3c9ae2894bd6429cf9812e7a1465ccf335890a13937

data/lib/trafaret.rb

@@ -3,35 +3,56 @@ require 'trafaret/version'
 require 'trafaret/errors'
 require 'trafaret/validator'
 require 'trafaret/validators'
+require 'trafaret/numeric'
 require 'trafaret/base'
+require 'trafaret/constructor'
 
 module Trafaret
-  def self.get_validator(validator)
-    if validator.is_a? Symbol
-      class_name = validator.to_s.classify
-      validator = Trafaret.const_get(class_name) rescue nil
-      validator ||= Kernel.const_get(class_name)
-    else
-      validator
-    end
+  module NoValue
   end
 
-  def self.get_instantiated_validator(validator, options = {})
-    val = self.get_validator(validator)
-    val = val.new(options) if val.is_a? Class
-    val
-  end
+  class << self
+    def get_validator(validator)
+      if validator.is_a? ::Symbol
+        class_name = validator.to_s.classify
+        validator = Trafaret.const_get(class_name) rescue nil
+        validator ||= Kernel.const_get(class_name)
+      else
+        validator
+      end
+    end
 
-  def self.[](validator, options = {})
-    return self.get_instantiated_validator(validator, options)
-  end
+    def get_instantiated_validator(validator, options = {})
+      val = self.get_validator(validator)
+      val = val.new(options) if val.is_a? Class
+      val
+    end
+
+    def [](validator, options = {})
+      return self.get_instantiated_validator(validator, options)
+    end
 
-  def self.method_missing(meth, *args, &blk)
-    cls = self.get_validator(meth)
-    if cls
-      cls.new(*args, &blk)
-    else
-      super
+    def method_missing(meth, *args, &blk)
+      cls = self.get_validator(meth)
+      if cls
+        cls.new(*args, &blk)
+      else
+        super
+      end
     end
+
+    def proc(*args, &blk)
+      Trafaret::Proc.new *args, &blk
+    end
+
+    def failure(msg)
+      Trafaret::Error.new msg
+    end
+
+    def construct(from)
+      Trafaret::Constructor.construct_from(from)
+    end
+
+    alias :f :failure
   end
 end

data/lib/trafaret/base.rb

@@ -2,69 +2,95 @@ module Trafaret
   class Key
     def initialize(name, validator, options = {}, &blk)
       @name = name
-      @validator = validator.new(options)
+      @sname = name.to_s
+
+      @optional = options.delete(:optional)
+      @default = options.delete(:default)
+      @to_name = options.delete(:to_name) || name
       @options = options
-      @blk = blk
-    end
 
-    def get(obj, extractors = {})
-      return @blk.call obj if @blk
-      data = begin
-               extractors[@name].call(obj) if extractors[@name]
-             rescue NoMethodError
-               nil
-             end
-      data ||= begin
-               obj.send(@name)
-             rescue NameError
-               nil
-             end
-      data ||= begin
-                 obj[@name] || obj[@name.to_s]
-               rescue NoMethodError, TypeError
-                 nil
-               end
+      set_validator(validator, options, &blk)
     end
 
-    def call(data, extractors = {})
-      [@name, @validator.call(get(data, extractors), &@blk)]
+    def set_validator(validator, options = {}, &blk)
+      validator = Trafaret.get_validator(validator)
+      @validator = if validator.is_a?(Class) then validator.new(options) else validator end
+      @validator.add(blk) if blk
     end
-  end
 
-  class Extractor
-    def initialize(&blk)
-      @blk = blk
+    def get(obj)
+      # data = obj.send(@name) if data.respond_to? @name
+      if obj.include? @name
+        obj[@name]
+      elsif obj.include? @sname
+        obj[@sname]
+      else
+        NoValue
+      end
     end
 
     def call(data)
-      @blk.call data
+      value = get(data)
+      if value == NoValue
+        if @default
+          value = @default
+        elsif @optional
+          return
+        else
+          return [@name, Trafaret::Error.new("#{@name} is required")]
+        end
+      end
+      value = @validator.call(value, &@blk)
+      if value.is_a? Trafaret::Error
+        [@name, value]
+      else
+        [@to_name, value]
+      end
     end
   end
 
   class Base < Validator
     module ClassMethods
-      attr_accessor :keys, :extractors
+      attr_accessor :keys
       def inherited(base)
         base.keys = (keys || []).dup
-        base.extractors = (extractors || {}).dup
       end
 
       def key(name, validator, options = {}, &blk)
-        @keys << Key.new(name, Trafaret.get_validator(validator), options, &blk)
-      end
-
-      def extract(name, &blk)
-        @extractors[name] = Extractor.new(&blk)
+        @keys << Key.new(name, validator, options, &blk)
       end
     end
     extend ClassMethods
 
+    attr_accessor :keys
+
+    def prepare
+      @keys = @options[:keys] || []
+      @keys.concat(self.class.keys || [])
+    end
+
+    def key(name, validator, options = {}, &blk)
+      @keys << Key.new(name, validator, options, &blk)
+    end
+
     def validate(data)
+      return failure('Not a Hash') unless data.is_a?(::Hash)
       res = []
-      self.class.keys.each do |key|
-        res << key.call(data, extractors = self.class.extractors)
+      fails = []
+      @keys.each do |key|
+        vdata = key.call(data)
+        next unless vdata
+        if vdata[1].is_a? Trafaret::Error
+          fails << vdata
+        else
+          res << vdata
+        end
+      end
+      if fails.blank?
+        Hash[res]
+      else
+        failure(Hash[fails])
       end
-      Hash[res]
     end
   end
 end

data/lib/trafaret/constructor.rb

@@ -0,0 +1,39 @@
+module Trafaret
+  class Constructor
+    class << self
+      def construct_from(from)
+        case from
+        when ::Hash
+          from_hash(from)
+        when ::Array
+          from_array(from)
+        when ::Symbol
+          Trafaret.get_validator from
+        when Trafaret::Validator
+          from
+        else
+          raise 'Wrong parameter'
+        end
+      end
+
+      def from_hash(params)
+        keys = []
+        params.each do |k, v|
+          v = Trafaret::Constructor.construct_from v
+          if k.is_a? ::Symbol
+            keys << Key.new(k, v)
+          elsif k.is_a? Trafaret::Key
+            k.set_validator(v)
+            keys << k
+          end
+        end
+        Trafaret::Base.new keys: keys
+      end
+
+      def from_array(params)
+        raise 'Wrong argument for array construction' if params.size != 1
+        Trafaret::Array.new validator: Trafaret::Constructor.construct_from(params[0])
+      end
+    end
+  end
+end

data/lib/trafaret/errors.rb

@@ -5,5 +5,9 @@ module Trafaret
     def initialize(message)
       @message = message
     end
+
+    def inspect
+      "#<Trafaret::Error(#{message.inspect})>"
+    end
   end
 end

data/lib/trafaret/numeric.rb

@@ -0,0 +1,45 @@
+module Trafaret
+  class Numeric < Validator
+    UNDEFINED = 'Undefined'.freeze
+    INTEGER = 'Integer'.freeze
+    FLOAT = 'Float'.freeze
+
+    def try_convert(arg)
+      raise 'type method need to be implemented'
+    end
+
+    def num_class_name
+      UNDEFINED
+    end
+
+    def validate(data)
+      val = try_convert(data)
+      return failure("Not an #{num_class_name}") unless val
+      return failure('Too big') if @options[:lt] && val >= @options[:lt]
+      return failure('Too big') if @options[:lte] && val > @options[:lte]
+      return failure('Too small') if @options[:gt] && val <= @options[:gt]
+      return failure('Too small') if @options[:gte] && val < @options[:gte]
+      data
+    end
+  end
+
+  class Integer < Numeric
+    def try_convert(arg)
+      Integer(arg) rescue nil
+    end
+
+    def num_class_name
+      INTEGER
+    end
+  end
+
+  class Float < Numeric
+    def try_convert(arg)
+      Float(arg) rescue nil
+    end
+
+    def num_class_name
+      FLOAT
+    end
+  end
+end

data/lib/trafaret/validator.rb

@@ -1,6 +1,14 @@
 class Trafaret::Validator
-  def initialize(options = {})
-    @options = options
+  def initialize(*args, &blk)
+    @options = (args.pop if args.last.is_a? Hash) || {}
+    @args = args
+    @converters = []
+    @converters << blk if blk
+
+    prepare
+  end
+
+  def prepare
   end
 
   def validate(data)
@@ -11,21 +19,41 @@ class Trafaret::Validator
     data
   end
 
+  def perform_convert(data)
+    if @converters.blank?
+      convert(data)
+    else
+      @converters.each do |c|
+        data = c.call(data)
+        break if data.is_a? Trafaret::Error
+      end
+      data
+    end
+  end
+
   def call(data)
     val = validate(data)
     return val if val.is_a? Trafaret::Error
     if block_given?
       yield val
     else
-      convert(val)
+      perform_convert(val)
     end
   end
 
+  def add(blk)
+    @converters << blk
+  end
+
   # ADT
   def |(other)
     Trafaret::Or.new(self, other)
   end
 
+  def &(other)
+    Trafaret::Chain.new(self, other)
+  end
+
   # Helpers
   def failure(msg)
     Trafaret::Error.new msg

data/lib/trafaret/validators.rb

@@ -2,14 +2,16 @@ module Trafaret
   class Any < Validator
   end
 
-  class Or < Validator
+  class ADT < Validator
     attr_reader :validators
 
     def initialize(*args)
       args = args.first if args.first.is_a? ::Array
       @validators = args.map { |v| Trafaret.get_instantiated_validator(v) }
     end
+  end
 
+  class Or < ADT
     def validate(data)
       errors = []
       @validators.each do |v|
@@ -28,6 +30,26 @@ module Trafaret
     end
   end
 
+  class Chain < ADT
+    def validate(data)
+      @validators.each do |v|
+        data = v.call(data)
+        return data if data.is_a? Trafaret::Error
+      end
+      data
+    end
+
+    def &(other)
+      Trafaret::Chain.new(*validators, other)
+    end
+  end
+
+  class Nil < Validator
+    def validate(data)
+      failure('Value must be nil') unless data.nil?
+    end
+  end
+
   class String < Validator
     def validate(data)
       return failure('Not a String') unless data.is_a? ::String
@@ -41,25 +63,99 @@ module Trafaret
       end
       data
     end
+
+    def convert(data)
+      if data.is_a? MatchData
+        data.string
+      else
+        data
+      end
+    end
   end
 
-  class Integer < Validator
+  class Symbol < Validator
+    def prepare
+      @sym = @args.first.to_sym
+      @str = @args.first.to_s.freeze
+    end
+
     def validate(data)
-      data.to_i
+      case data
+      when ::String
+        @str == data ? @sym : failure('Not equal')
+      when ::Symbol
+        @sym == data ? @sym : failure('Not equal')
+      else
+        failure('Not a String or a Symbol')
+      end
     end
   end
 
   class Array < Validator
+    def prepare
+      val = Trafaret.get_validator(@options[:validator])
+      if val.is_a? ::Class
+        @cls = Trafaret.get_validator(@options[:validator]).new @options
+      else
+        @cls = val
+      end
+    end
+
     def self.[](validator, options = {})
       self.new(options.merge(validator: validator))
     end
 
     def validate(data)
       return failure('Not an Array') unless data.is_a? ::Array
-      cls = Trafaret.get_validator(@options[:validator]).new @options
-      data.map do |elem|
-        cls.call elem
+      fails = {}
+      res = data.map.with_index do |elem, index|
+        val = @cls.call elem
+        fails[index] = val if val.is_a? Trafaret::Error
+        val
+      end
+      if fails.blank?
+        return res
+      else
+        return failure(fails)
+      end
+    end
+  end
+
+  class Mapping < Validator
+    def prepare
+      @key_validator = @args.first
+      @value_validator = @args[1]
+    end
+
+    def validate(data)
+      return failure('Not a Hash') unless data.is_a? ::Hash
+      fails = []
+      pairs = []
+      data.each do |k, v|
+        kv = @key_validator.call(k)
+        vv = @value_validator.call(v)
+        if (kv.is_a? Trafaret::Error) || (vv.is_a? Trafaret::Error)
+          fails << [k, [kv, vv]]
+        else
+          pairs << [kv, vv]
+        end
       end
+      if fails.blank?
+        Hash[pairs]
+      else
+        failure(Hash[fails])
+      end
+    end
+  end
+
+  class Proc < Validator
+    def prepare
+      raise 'Need to call with block' if @converters.blank?
+      @blk = @converters.pop
+    end
+
+    def validate(data)
+      @blk.call(data)
     end
   end
 end

data/lib/trafaret/version.rb

@@ -1,3 +1,3 @@
 module Trafaret
-  VERSION = "1.1.0"
+  VERSION = "1.5.1"
 end

data/spec/trafaret_spec.rb

@@ -1,18 +1,19 @@
 # -*- coding: utf-8 -*-
 require 'trafaret'
 
-class ProviderTrafaret < Trafaret::Base
-  key :url, Trafaret::String, min_length: 3, max_length: 50
-end
+T = Trafaret
 
 class FacebookResponseTrafaret < Trafaret::Base
-  key :name, :string, optional: true, min_length: 2
-  extract :providers do |data|
-    data['oa'].flat_map do |prov_name, accs|
-      accs.map { |uuid, data| data }
-    end
+  key :name, T.string(min_length: 2), optional: true
+  key :oa, T.mapping(T.string,
+    T.mapping(T.string,
+      T.base(keys: [T.key(:url, T.string)])
+    )
+  ), to_name: :providers do |data| # so we have response that matches our assumptions, then we can convert it
+    data.flat_map { |p_n, accs| accs.map { |uuid, data| data } }
   end
-  key :providers, :array, validator: :provider_trafaret
+  key :dwarf, :string, default: 'Sniffer'
+  key :optional_key, :string, optional: true
 end
 
 describe Trafaret::Base do
@@ -27,35 +28,115 @@ describe Trafaret::Base do
     }
   end
   it 'should work' do
-    FacebookResponseTrafaret.new.call(raw).should == ({name: "kuku", providers: [{url: "http://ya.ru"}, {url: "http://www.ru"}]})
+    FacebookResponseTrafaret.new.call(raw).should == ({name: "kuku", providers: [{url: "http://ya.ru"}, {url: "http://www.ru"}], dwarf: 'Sniffer'})
+  end
+
+  it 'should work with hash' do
+    t = T.construct({
+      kuku: :integer,
+      T.key(:krkr, nil, to_name: :id) => :string,
+      argh: {
+        karma: :integer
+      },
+      arr: [{id: :integer}]
+    })
+    res = t.call({kuku: 123, krkr: 'karma', argh: {karma: 234}, arr: [{id: 123}, {id: 234}]})
+    res[:id].should == 'karma'
+    res[:argh][:karma].should == 234
   end
 end
 
 describe Trafaret::String do
   it 'should check errors' do
-    Trafaret.string.call('').message.should == 'Should not be blank'
-    Trafaret.string(min_length: 10).call('abc').message.should == 'Too short'
-    Trafaret.string(max_length: 1).call('abc').message.should == 'Too long'
-    Trafaret.string(regex: /abc/).call('bca').message.should == 'Does not match'
+    T.string.call('').message.should == 'Should not be blank'
+    T.string(min_length: 10).call('abc').message.should == 'Too short'
+    T.string(max_length: 1).call('abc').message.should == 'Too long'
+    T.string(regex: /abc/).call('bca').message.should == 'Does not match'
+  end
+end
+
+describe Trafaret::Integer do
+  it 'should check errors' do
+    T.integer.call('blabla').message.should == 'Not an Integer'
+    T.integer(lt: 5).call(5).message.should == 'Too big'
+    T.integer(lte: 5).call(6).message.should == 'Too big'
+    T.integer(gt: 5).call(5).message.should == 'Too small'
+    T.integer(gte: 5).call(4).message.should == 'Too small'
+  end
+end
+
+describe Trafaret::Validator do
+  it 'should work with block' do
+    blk = proc { |data| if data.present? then data else T::Error.new('Empty data') end }
+    T::Validator.new(&blk).call('argh').should == 'argh'
+    T::Validator.new(&blk).call('').message.should == 'Empty data'
+    T.proc(&blk).call('').message.should == 'Empty data'
   end
 end
 
 describe Trafaret::Array do
   it 'should check' do
-    Trafaret::Array[:string].call(['a', 'b', 'c']).should == ['a', 'b', 'c']
+    T::Array[:string].call(['a', 'b', 'c']).should == ['a', 'b', 'c']
+    T::Array[:string].call(['a', 'b', nil]).should.is_a? Trafaret::Error
   end
 end
 
 describe Trafaret::Or do
   it 'should return value' do
-    Trafaret[:or, [:string, :integer]].call('krukatuka').should == 'krukatuka'
+    T[:or, [:string, :integer]].call('krukatuka').should == 'krukatuka'
 
-    (Trafaret[:string] | Trafaret[:integer]).call('krukatuka').should == 'krukatuka'
+    (T[:string] | T[:integer]).call('krukatuka').should == 'krukatuka'
 
-    (Trafaret.string | Trafaret.integer).call('krukatuka').should == 'krukatuka'
+    (T.string | T.integer).call('krukatuka').should == 'krukatuka'
   end
 
   it 'should return errors' do
-    Trafaret[:or, Trafaret[:array, validator: :string]].call('krukatuka').message.first.message.should == 'Not an Array'
+    T[:or, T[:array, validator: :string]].call('krukatuka').message.first.message.should == 'Not an Array'
+  end
+
+  it 'should properly chained' do
+    (T.string(min_length: 100) | T.integer | T.string(regex: /aaa/)).call('aaa').should == 'aaa'
+  end
+end
+
+describe Trafaret::Chain do
+  it 'should work with callables' do
+    trafaret = T.integer & proc { |d| d == 123? d : T.f('not equal') }
+    trafaret.call(123).should == 123
+    trafaret.call(321).message.should == 'not equal'
+    trafaret = T.integer & proc { |d| d }
+    trafaret.call('abc').message.should == 'Not an Integer'
+  end
+end
+
+
+describe Trafaret::Key do
+  it 'should extract and check value' do
+    T.key(:name, :string).call({name: 'cow'}).should == [:name, 'cow']
+    T.key(:name, :string, default: 'Elephant').call({}).should == [:name, 'Elephant']
+    T.key(:name, :string, optional: true).call({}).should == nil
+    # to name test
+    T.key(:name, :string, to_name: :id).call({name: '123'}).should == [:id, '123']
+    T.key(:name, :string, to_name: :id).call({name: 123})[0].should == :name
+  end
+end
+
+describe Trafaret::Symbol do
+  it 'should check equality' do
+    T.symbol(:name).call('name').should == :name
+    T.symbol(:name).call(:name).should == :name
+  end
+
+  it 'should fail' do
+    T.symbol(:name).call('pame').message.should == 'Not equal'
+    T.symbol(:name).call(123).message.should == 'Not a String or a Symbol'
+  end
+end
+
+describe Trafaret::Nil do
+  it 'should check for nil' do
+    n = T::Nil.new
+    n.call(123).message.should == 'Value must be nil'
+    n.call(nil).should == nil
   end
 end

metadata

@@ -1,41 +1,41 @@
 --- !ruby/object:Gem::Specification
 name: trafaret
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.5.1
 platform: ruby
 authors:
 - Mikhail Krivushin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-26 00:00:00.000000000 Z
+date: 2014-04-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.5'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.5'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: |-
@@ -47,14 +47,16 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
+- ".gitignore"
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - lib/trafaret.rb
 - lib/trafaret/base.rb
+- lib/trafaret/constructor.rb
 - lib/trafaret/errors.rb
+- lib/trafaret/numeric.rb
 - lib/trafaret/validator.rb
 - lib/trafaret/validators.rb
 - lib/trafaret/version.rb
@@ -70,17 +72,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Convert data structures. Like a RABL.