type_struct 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cf544085d5325212144ddfb4119b2360807e1869
-  data.tar.gz: 2c7efe99a85c7442ddc2fc5b304bb55ca9e78ac1
+  metadata.gz: 155aa214f6353b480dc87c69555db00a31623f7d
+  data.tar.gz: 31e28839d1fa9930ba9fddddf288f32dbeb02dee
 SHA512:
-  metadata.gz: 6b6872ff8ea9c9bcb43c2743726a8458a7d0018a98f81191c511d03a700df971794de75f6d75ffbef9f8ff94e12230fb1483ede2c8cd66581ac7b94c97b4cfe5
-  data.tar.gz: 93d5f28458f94944711361846df2ecdb9223ee87d8636444fb8cedba51a0068088679c53873c37a08f7c0b2d00118feda067eb2f38c565964c4cd9ff122a3362
+  metadata.gz: 56c32708f5d233891dbfeda2a403fffb04d2d8e7a674749a6f6f1c80eadae3f6ac868815299c608cb156585768d0aaffee01a8bff9590530fe7b4d99991885bc
+  data.tar.gz: dffe91d28e705eee66d507a3552d94d2a7ece6bd6d52be9d949643e50eebb3568a4cd7e9ee4c4363b5321b397c332728edb002310d758b810af674ab1a6265c1

data/README.md

@@ -109,7 +109,9 @@ sample.str = 1 #=> TypeError
 
 ### Recursive Mapping
 
-Generate object from hash by recursive
+Generate object from hash by recursive.
+
+Like JSON package of golang and crystal-lang.
 
 ```ruby
 Point = TypeStruct.new(

data/lib/type_struct/exceptions.rb

@@ -0,0 +1,25 @@
+class TypeStruct
+  UnionNotFoundError = Class.new(StandardError)
+
+  class MultiTypeError < StandardError
+    THIS_LIB_REGEXP = %r{lib/type_struct[./]}
+    PWD = Pathname.new(Dir.pwd)
+    attr_reader :errors
+    def initialize(errors)
+      @errors = errors
+      super("\n#{build_message}")
+    end
+
+    private
+
+    def build_message
+      @errors.map { |e|
+        b = e.backtrace_locations.find do |b|
+          b.absolute_path !~ THIS_LIB_REGEXP
+        end
+        relative_path = Pathname.new(b.absolute_path).relative_path_from(PWD)
+        "#{relative_path}:#{b.lineno}:in #{e.class} #{e}"
+      }.join("\n")
+    end
+  end
+end

data/lib/type_struct/version.rb

@@ -1,3 +1,3 @@
 class TypeStruct
-  VERSION = "0.5.0"
+  VERSION = "0.6.0"
 end

data/lib/type_struct.rb

@@ -1,34 +1,44 @@
+require 'pathname'
+
 class TypeStruct
   require "type_struct/union"
   require "type_struct/array_of"
   require "type_struct/hash_of"
   require "type_struct/interface"
+  require "type_struct/exceptions"
   require "type_struct/version"
 
-  UnionNotFoundError = Class.new(StandardError)
-
   def initialize(arg)
     sym_arg = {}
     arg.each do |k, v|
       sym_arg[k.to_sym] = v
     end
-    self.class.members.each do |k|
-      self[k] = sym_arg[k]
+    errors = []
+    klass = self.class
+    klass.members.each do |k|
+      unless klass.valid?(k, sym_arg[k])
+        begin
+          raise TypeError, "#{klass}##{k} expect #{klass.type(k)} got #{sym_arg[k].inspect}"
+        rescue TypeError => e
+          errors << e
+        end
+      end
+      instance_variable_set("@#{k}", sym_arg[k])
     end
+    raise MultiTypeError, errors unless errors.empty?
   end
 
   def ==(other)
     return false unless TypeStruct === other
-    return false unless to_h == other.to_h
-    true
+    to_h == other.to_h
   end
 
   def []=(k, v)
-    __send__("#{k}=", v)
+    __send__ "#{k}=", v
   end
 
   def [](k)
-    __send__(k)
+    __send__ k
   end
 
   def inspect
@@ -47,97 +57,117 @@ class TypeStruct
     m
   end
 
-  class << self
-    alias original_new new
-    def new(**args, &block)
-      c = Class.new(TypeStruct) do
-        const_set :DEFINITION, args
+  module ClassMethods
+    def from_hash(h)
+      unless Hash === h
+        h = h.to_hash if h.respond_to?(:to_hash)
+        unless Hash === h
+          raise TypeError, "#{self}.from_hash only accept Hash got `#{h.class}'"
+        end
+      end
+      args = {}
+      errors = []
+      h.each do |key, value|
+        key = key.to_sym
+        t = type(key)
+        args[key] = try_convert(t, key, value, errors)
+      end
+      raise MultiTypeError, errors unless errors.empty?
+      new(args)
+    end
 
-        class << self
-          alias_method :new, :original_new
+    def definition
+      const_get(:DEFINITION)
+    end
 
-          def from_hash(h)
-            unless Hash === h
-              h = h.to_hash if h.respond_to?(:to_hash)
-              unless Hash === h
-                raise TypeError, "#{self}.from_hash only accept Hash got `#{h.class}'"
-              end
-            end
-            args = {}
-            h.each do |key, value|
-              key = key.to_sym
-              t = type(key)
-              args[key] = try_convert(t, key, value)
-            end
-            new(args)
-          end
+    def members
+      definition.keys
+    end
 
-          def definition
-            const_get(:DEFINITION)
-          end
+    def type(k)
+      definition[k]
+    end
 
-          def members
-            definition.keys
-          end
+    def valid?(k, v)
+      definition[k] === v
+    end
 
-          def type(k)
-            definition[k]
+    private
+
+    def try_convert(klass, key, value, errors)
+      case klass
+      when Union
+        union_errors = []
+        klass.each do |k|
+          begin
+            return try_convert(k, key, value, nil)
+          rescue TypeError, MultiTypeError => e
+            union_errors << e
           end
+        end
 
-          def valid?(k, v)
-            definition[k] === v
+        raise UnionNotFoundError, "#{klass} is not found with value `#{value}'\nerrors:\n#{union_errors.join("\n")}"
+      when ArrayOf
+        unless Array === value
+          begin
+            raise TypeError, "#{self}##{key} expect #{klass.inspect} got #{value.inspect}"
+          rescue TypeError => e
+            raise unless errors
+            errors << e
           end
-
-          private
-
-          def try_convert(klass, key, value)
-            return nil unless !klass.nil? && !value.nil?
-
-            case klass
-            when Union
-              errors = []
-              klass.each do |k|
-                t = begin
-                      try_convert(k, key, value)
-                    rescue TypeError => e
-                      errors << e
-                      nil
-                    end
-                return t if !t.nil?
-              end
-              raise UnionNotFoundError, "#{klass} is not found with value `#{value}'\nerrors:\n#{errors.join("\n")}"
-            when ArrayOf
-              unless Array === value
-                raise TypeError, "#{self}##{key} expect #{klass.inspect} got #{value.inspect}"
-              end
-              value.map { |v| try_convert(klass.type, key, v) }
-            when HashOf
-              unless Hash === value
-                raise TypeError, "#{self}##{key} expect #{klass.inspect} got #{value.inspect}"
-              end
-              new_hash = {}
-              value.each do |hk, hv|
-                new_hash[hk] = try_convert(klass.value_type, key, hv)
-              end
-              new_hash
-            else
-              if klass.respond_to?(:ancestors)
-                if klass.ancestors.include?(TypeStruct)
-                  klass.from_hash(value)
-                elsif klass.ancestors.include?(Struct)
-                  struct = klass.new
-                  value.each { |k, v| struct[k] = v }
-                  struct
-                elsif klass === value
-                  value
-                else
-                  raise TypeError, "#{self}##{key} expect #{klass.inspect} got #{value.inspect}"
-                end
-              else
-                value
-              end
+          return value
+        end
+        value.map { |v| try_convert(klass.type, key, v, errors) }
+      when HashOf
+        unless Hash === value
+          begin
+            raise TypeError, "#{self}##{key} expect #{klass.inspect} got #{value.inspect}"
+          rescue TypeError => e
+            raise unless errors
+            errors << e
+          end
+          return value
+        end
+        new_hash = {}
+        value.each do |hk, hv|
+          new_hash[hk] = try_convert(klass.value_type, key, hv, errors)
+        end
+        new_hash
+      else
+        if klass.respond_to?(:ancestors)
+          if klass.ancestors.include?(TypeStruct)
+            klass.from_hash(value)
+          elsif klass.ancestors.include?(Struct)
+            struct = klass.new
+            value.each { |k, v| struct[k] = v }
+            struct
+          elsif klass === value
+            value
+          else
+            begin
+              raise TypeError, "#{self}##{key} expect #{klass} got #{value.inspect}"
+            rescue => e
+              raise unless errors
+              errors << e
             end
+            value
           end
+        else
+          value
+        end
+      end
+    end
+  end
+
+  class << self
+    alias original_new new
+    def new(**args, &block)
+      c = Class.new(TypeStruct) do
+        extend ClassMethods
+        const_set :DEFINITION, args
+
+        class << self
+          alias_method :new, :original_new
         end
 
         args.each_key do |k|
@@ -153,6 +183,7 @@ class TypeStruct
           end
         end
       end
+
       if block_given?
         c.module_eval(&block)
       end

data/lib/type_struct_benchmark_test.rb

@@ -16,6 +16,40 @@ module TypeStructBenchmarkTest
     end
   end
 
+  def benchmark_struct_new(b)
+    i = 0
+    while i < b.n
+      Struct.new(:a, :b, :c)
+      i += 1
+    end
+  end
+
+  def benchmark_new_instance(b)
+    t = TypeStruct.new(
+      a: String,
+      b: Integer,
+      c: Regexp,
+    )
+    hash = { a: "aaa".freeze, b: 1, c: /abc/ }
+    i = 0
+    while i < b.n
+      t.new(hash)
+      i += 1
+    end
+  end
+
+  def benchmark_struct_new_instance(b)
+    t = Struct.new(:a, :b, :c)
+    a1 = "aaa".freeze
+    a2 = 1
+    a3 = /abc/
+    i = 0
+    while i < b.n
+      t.new(a1, a2, a3)
+      i += 1
+    end
+  end
+
   A = TypeStruct.new(
     a: Integer,
   )
@@ -34,8 +68,9 @@ module TypeStructBenchmarkTest
 
   def benchmark_from_hash(b)
     i = 0
+    hash = { e: { d: { c: { b: { a: 1 } } } } }
     while i < b.n
-      E.from_hash(e: { d: { c: { b: { a: 1 } } } })
+      E.from_hash(hash)
       i += 1
     end
   end

data/lib/type_struct_test.rb

@@ -89,7 +89,7 @@ module TypeStructTest
       hc.new(
         a: [],
       )
-    rescue TypeError
+    rescue TypeStruct::MultiTypeError
     else
       t.error("TypeError was not railsed")
     end
@@ -103,7 +103,7 @@ module TypeStructTest
 
     begin
       hh = hc.from_hash(a: 1)
-    rescue TypeError
+    rescue TypeStruct::MultiTypeError
     else
       t.error("TypeError dose not raise error")
     end
@@ -114,35 +114,27 @@ module TypeStructTest
     begin
       hsbn.from_hash(a: [])
     rescue TypeStruct::UnionNotFoundError
-    rescue => e
-      t.error("Unexpected error #{e.class}: #{e.message}")
     else
       t.error("Unexpected behavior")
     end
 
     begin
-      hsbn.from_hash(a: {a: {b: 1.1}})
+      hsbn.from_hash(a: { a: { b: 1.1 } })
     rescue TypeStruct::UnionNotFoundError
-    rescue => e
-      t.error("Unexpected error #{e.class}: #{e.message}")
     else
       t.error("Unexpected behavior")
     end
 
     begin
-      hsbn.from_hash(a: {"a" => {b: 1}})
-    rescue TypeError
-    rescue => e
-      t.error("Unexpected error #{e.class}: #{e.message}")
+      hsbn.from_hash(a: { "a" => { b: 1 } })
+    rescue TypeStruct::MultiTypeError
     else
       t.error("Unexpected behavior")
     end
 
     begin
-      hsbn.from_hash(a: {"a" => {b: 1.1}})
+      hsbn.from_hash(a: { "a" => { b: 1.1 } })
     rescue TypeStruct::UnionNotFoundError
-    rescue => e
-      t.error("Unexpected error #{e.class}: #{e.message}")
     else
       t.error("Unexpected behavior")
     end
@@ -165,9 +157,7 @@ module TypeStructTest
     a = TypeStruct.new(a: ArrayOf(Integer))
     begin
       a.from_hash(a: [1.1])
-    rescue TypeError
-    rescue => e
-      t.error("Unexpected error #{e.class}")
+    rescue TypeStruct::MultiTypeError
     else
       t.error("Nothing raised TypeError")
     end
@@ -176,8 +166,6 @@ module TypeStructTest
     begin
       b.from_hash(a: [1.1])
     rescue TypeStruct::UnionNotFoundError
-    rescue => e
-      t.error("Unexpected error #{e.class}")
     else
       t.error("Nothing raised TypeStruct::UnionNotFoundError")
     end
@@ -185,10 +173,8 @@ module TypeStructTest
     c = TypeStruct.new(c: Integer)
     d = TypeStruct.new(d: ArrayOf(c) | NilClass)
     begin
-      d.from_hash(d: [{c: 1.1}])
+      d.from_hash(d: [{ c: 1.1 }])
     rescue TypeStruct::UnionNotFoundError
-    rescue => e
-      t.error("Unexpected error #{e.class}")
     else
       t.error("Nothing raised TypeStruct::UnionNotFoundError")
     end
@@ -236,7 +222,7 @@ module TypeStructTest
 
     begin
       foo.from_hash(bar: { baz: nil })
-    rescue TypeError
+    rescue TypeStruct::MultiTypeError
     else
       t.error("Bar.baz is not able to nil")
     end
@@ -255,7 +241,7 @@ module TypeStructTest
     end
 
     def o.to_hash
-      {a: 1}
+      { a: 1 }
     end
     unless a === a.from_hash(o)
       t.error("Unexpected behavior")
@@ -263,30 +249,36 @@ module TypeStructTest
   end
 
   def test_s_from_hash_with_array_of(t)
-    a = TypeStruct.new(a: ArrayOf(Integer))
+    a = TypeStruct.new(a: ArrayOf(Integer), b: Integer)
     begin
-      a.from_hash(a: 1)
-    rescue TypeError => e
-      unless /#a expect ArrayOf\(Integer\) got 1/ =~ e.message
-        t.error("message was changed: #{e.message}")
+      a.from_hash(a: 1, b: 'a')
+    rescue TypeStruct::MultiTypeError => e
+      [
+        /#a expect ArrayOf\(Integer\) got 1/,
+        /#b expect Integer got "a"/,
+      ].each do |expect|
+        unless expect =~ e.message
+          t.error("message was changed: #{e.message}")
+        end
       end
-    rescue => e
-      t.error("Unexpected error #{e}")
     else
       t.error("Unexpected behavior")
     end
   end
 
   def test_s_from_hash_with_hash_of(t)
-    a = TypeStruct.new(a: HashOf(String, Integer))
+    a = TypeStruct.new(a: HashOf(String, Integer), b: Integer)
     begin
-      a.from_hash(a: 1)
-    rescue TypeError => e
-      unless /#a expect HashOf\(String, Integer\) got 1/ =~ e.message
-        t.error("message was changed: #{e.message}")
+      a.from_hash(a: 1, b: 'a')
+    rescue TypeStruct::MultiTypeError => e
+      [
+        /#a expect HashOf\(String, Integer\) got 1/,
+        /#b expect Integer got "a"/,
+      ].each do |expect|
+        unless expect =~ e.message
+          t.error("message was changed: #{e.message}")
+        end
       end
-    rescue => e
-      t.error("Unexpected error #{e}")
     else
       t.error("Unexpected behavior")
     end
@@ -296,7 +288,7 @@ module TypeStructTest
     a = TypeStruct.new(a: "a")
     begin
       a.from_hash(a: "b")
-    rescue TypeError
+    rescue TypeStruct::MultiTypeError
     else
       t.error("Unexpected behavior")
     end
@@ -309,11 +301,7 @@ module TypeStructTest
     u = TypeStruct::Union.new(a, b, c)
     d = TypeStruct.new(d: u)
 
-    begin
-      d.from_hash(d: { b: 1 })
-    rescue => e
-      t.error("Unexpected error was raised #{e.class}: #{e.message}")
-    end
+    d.from_hash(d: { b: 1 })
 
     begin
       d.from_hash(d: [b: 1])
@@ -516,6 +504,87 @@ module TypeStructTest
     end
   end
 
+  def test_multi_type_error(t)
+    a = TypeStruct.new(
+      a: Integer,
+      b: Integer,
+      c: Integer,
+    )
+    begin
+      a.new(
+        a: 'a',
+        b: 1,
+        c: '1',
+      )
+    rescue TypeStruct::MultiTypeError => err
+      unless err.errors.all? { |e| TypeError === e }
+        t.error("Empty errors")
+      end
+
+      [
+        /a expect Integer got "a"/,
+        /c expect Integer got "1"/,
+      ].each do |reg|
+        unless reg =~ err.message
+          t.error("should match error message #{reg} got #{err.message}")
+        end
+      end
+    rescue => err
+      raise err
+    else
+      t.error("Nothing raised an error")
+    end
+  end
+
+  def test_s_from_hash_multi_type_error(t)
+    a = TypeStruct.new(
+      a: Integer,
+      b: String,
+      c: ArrayOf(String),
+    )
+    b = TypeStruct.new(
+      b: a,
+    )
+    begin
+      b.from_hash(b: { a: '1', b: 1, c: /a/ })
+    rescue TypeStruct::MultiTypeError => err
+      unless err.errors.all? { |e| TypeError === e }
+        t.error("Empty errors")
+      end
+
+      [
+        /a expect Integer got "1"/,
+        /b expect String got 1/,
+        %r{c expect ArrayOf\(String\) got /a/},
+      ].each do |reg|
+        unless reg =~ err.message
+          t.error("should match error message #{reg} got #{err.message}")
+        end
+      end
+    end
+  end
+
+  def test_s_from_hash_multi_type_error_with_union(t)
+    a = TypeStruct.new(
+      a: ArrayOf(String) | NilClass,
+    )
+    b = TypeStruct.new(
+      b: a,
+    )
+    begin
+      b.from_hash(b: { a: '1' })
+    rescue TypeStruct::UnionNotFoundError => err
+      [
+        /a expect ArrayOf\(String\) got "1"/,
+        /a expect NilClass got "1"/,
+      ].each do |reg|
+        unless reg =~ err.message
+          t.error("should match error message #{reg} got #{err.message}")
+        end
+      end
+    end
+  end
+
   def test_getter(t)
     dummy = Dummy.new(str: "aaa", num: 123, reg: "abc", any: [1, "bbb"])
     _, err = go { dummy[:str] }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: type_struct
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - ksss
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-29 00:00:00.000000000 Z
+date: 2016-04-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -68,6 +68,7 @@ files:
 - lib/type_struct.rb
 - lib/type_struct/array_of.rb
 - lib/type_struct/array_of_test.rb
+- lib/type_struct/exceptions.rb
 - lib/type_struct/ext.rb
 - lib/type_struct/hash_of.rb
 - lib/type_struct/hash_of_test.rb
@@ -99,7 +100,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.1
+rubygems_version: 2.6.2
 signing_key: 
 specification_version: 4
 summary: Imitating static typed struct.