type_struct 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7cb90a5e3baaac22f77fc721160e434f7d79a4fe
-  data.tar.gz: 5db1cae7790e5cc16b89f9d17a386e33958ad88f
+  metadata.gz: cf544085d5325212144ddfb4119b2360807e1869
+  data.tar.gz: 2c7efe99a85c7442ddc2fc5b304bb55ca9e78ac1
 SHA512:
-  metadata.gz: 0caefd5bf92dc35fc51774741a110b8a712a97ee333a7f7fd170b0a3e90675fe02050570cb2fc452865a92985fbe8b3189dcfa3c91d473f413935e55c4e267d2
-  data.tar.gz: 3d88d07143f6455aadab4723c1e761a49b8e152c905669a9250030cce67cce2cd324e0f6c79c419467aef3ba5445d7308c5ecb3c518eecceddda022320f46c7d
+  metadata.gz: 6b6872ff8ea9c9bcb43c2743726a8458a7d0018a98f81191c511d03a700df971794de75f6d75ffbef9f8ff94e12230fb1483ede2c8cd66581ac7b94c97b4cfe5
+  data.tar.gz: 93d5f28458f94944711361846df2ecdb9223ee87d8636444fb8cedba51a0068088679c53873c37a08f7c0b2d00118feda067eb2f38c565964c4cd9ff122a3362

data/README.md

@@ -6,6 +6,75 @@ Imitating static typed struct.
 
 All type is checked by `===` method.
 
+## Motivation
+
+### I don't like Hash
+
+```ruby
+p h #=> {color: 'red', width: 120, height: 200}
+```
+
+**No name**
+
+What is this a data?
+We cannot know this name.
+
+Where is this an instance from?
+How do we grep doing?
+
+**Bad syntax**
+
+```ruby
+h[:widht] #=> Cannot detect typo
+#=> nil
+h.dig(:widht) #=> ditto
+#=> nil
+h.fetch(:widht) #=> Can detect typo, But too long and cannot know suggestion from did_you_mean gem
+# KeyError: key not found: :widht
+```
+
+**Too freedom**
+
+```ruby
+# Where is from `who` key? Is this expected?
+p h #=> {color: 'red', width: 120, height: 200, who: 'are you?'}
+```
+
+### I like Struct
+
+**Grepable Name**
+
+```ruby
+Circle = Struct.new(:color, :width, :height)
+circle = Circle.new('red', 120, 200)
+```
+
+**Good syntax**
+
+```ruby
+circle.color
+#=> 'red'
+circle.widht
+# NoMethodError:
+Did you mean?  width
+               width=
+```
+
+**Strictly members**
+
+```ruby
+circle.who = "are you?"
+# NoMethodError: undefined method `who='
+```
+
+## Evolution
+
+- Can use keyword arguments
+- Add **Type** system
+- Recursive Mapping
+
+This is the **TypeStruct**.
+
 ## Usage
 
 ### Check type
@@ -38,16 +107,18 @@ sample.string #=> NoMethodError
 sample.str = 1 #=> TypeError
 ```
 
-### Mapping from Hash
+### Recursive Mapping
 
-Generate object from hash recursive
+Generate object from hash by recursive
 
 ```ruby
 Point = TypeStruct.new(
   x: Integer,
   y: Integer,
 )
-Color = Struct.new(:code)
+Color = TypeStruct.new(
+  code: /\A#[0-9a-f]{6}\z/i,
+)
 Line = TypeStruct.new(
   start: Point,
   end: Point,
@@ -58,18 +129,18 @@ hash = JSON.parse(%({"start":{"x":3,"y":10},"end":{"x":5,"y":9},"color":{"code":
 line = Line.from_hash(hash)
 
 p line
-#=> #<Line start=#<Point x=3, y=10>, end=#<Point x=5, y=9>, color=#<struct Color code="#CAFE00">>
+#=> #<Line start=#<Point x=3, y=10>, end=#<Point x=5, y=9>, color=#<Color code="#CAFE00">>
 p line.start.y
 #=> 10
 line.stort
 #=> NoMethodError
 ```
 
-## Four special notation
+## Four special classes
 
 ### Union
 
-Union is a object express class that some classes as one class like crystal `Union`.
+Union is an object express class that some classes as one class like crystal `Union`.
 
 `Union#===` check all object with `===` method.
 
@@ -92,7 +163,7 @@ Foo = TypeStruct.new(
 
 ### ArrayOf
 
-ArrayOf is a object express array type.
+ArrayOf is an object express array type.
 
 `ArrayOf#===` check all item with `===` method.
 
@@ -119,7 +190,7 @@ p Baz.new(qux: { "a" => [1, 2, nil] }) #=> TypeError
 
 ### Interface
 
-Interface is a object for duck typing like golang `interface`.
+Interface is an object for duck typing like golang `interface`.
 
 `Interface#===` check all method using `respond_to?`
 

data/Rakefile

@@ -1,7 +1,7 @@
 require "bundler/gem_tasks"
 
 task :test do
-  sh "rgot -v lib"
+  sh "rgot -v --bench ."
 end
 
 task :default => [:test]

data/lib/type_struct.rb

@@ -57,11 +57,17 @@ class TypeStruct
           alias_method :new, :original_new
 
           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, value)
+              args[key] = try_convert(t, key, value)
             end
             new(args)
           end
@@ -84,43 +90,52 @@ class TypeStruct
 
           private
 
-          def try_convert(klass, value)
+          def try_convert(klass, key, value)
             return nil unless !klass.nil? && !value.nil?
 
-            if Union === klass
+            case klass
+            when Union
               errors = []
               klass.each do |k|
                 t = begin
-                      try_convert(k, value)
+                      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 errors:\n#{errors.join("\n")}"
-            elsif ArrayOf === klass
-              value.map { |v| try_convert(klass.type, v) }
-            elsif HashOf === klass
-              return value unless Hash === value
+              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, hv)
+                new_hash[hk] = try_convert(klass.value_type, key, hv)
               end
               new_hash
-            elsif klass.respond_to?(:ancestors)
-              if klass.ancestors.include?(TypeStruct)
-                return nil unless Hash === value
-                klass.from_hash(value)
-              elsif klass.ancestors.include?(Struct)
-                struct = klass.new
-                value.each { |k, v| struct[k] = v }
-                struct
+            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
-            else
-              value
             end
           end
         end

data/lib/type_struct/ext.rb

@@ -12,24 +12,28 @@ class TypeStruct
     def to_s
       "#{self.class.name.split('::').last}(#{@type})"
     end
+    alias inspect to_s
   end
 
   class HashOf
     def to_s
       "#{self.class.name.split('::').last}(#{@key_type}, #{@value_type})"
     end
+    alias inspect to_s
   end
 
   class Interface
     def to_s
       "#<#{self.class.name.split('::').last}(#{@methods.map(&:inspect).join(',')})>"
     end
+    alias inspect to_s
   end
 
   class Union
     def to_s
       "#<#{self.class.name.split('::').last} #{@classes.join('|')}>"
     end
+    alias inspect to_s
   end
 end
 

data/lib/type_struct/hash_of.rb

@@ -20,5 +20,6 @@ class TypeStruct
     def to_s
       "#{self.class}(#{@key_type}, #{@value_type})"
     end
+    alias inspect to_s
   end
 end

data/lib/type_struct/version.rb

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

data/lib/type_struct_benchmark_test.rb

@@ -0,0 +1,42 @@
+require "type_struct"
+require "type_struct/ext"
+
+module TypeStructBenchmarkTest
+  using TypeStruct::Union::Ext
+
+  def benchmark_new(b)
+    i = 0
+    while i < b.n
+      TypeStruct.new(
+        a: String,
+        b: Integer,
+        c: Regexp,
+      )
+      i += 1
+    end
+  end
+
+  A = TypeStruct.new(
+    a: Integer,
+  )
+  B = TypeStruct.new(
+    b: A,
+  )
+  C = TypeStruct.new(
+    c: B,
+  )
+  D = TypeStruct.new(
+    d: C,
+  )
+  E = TypeStruct.new(
+    e: D,
+  )
+
+  def benchmark_from_hash(b)
+    i = 0
+    while i < b.n
+      E.from_hash(e: { d: { c: { b: { a: 1 } } } })
+      i += 1
+    end
+  end
+end

data/lib/type_struct_test.rb

@@ -12,23 +12,6 @@ module TypeStructTest
     any: Object,
   ); end
 
-  class Quux < Struct.new(:q)
-  end
-
-  class Qux < TypeStruct.new(
-    quux1: Quux,
-    quux2: Quux,
-  ); end
-
-  class Bar < TypeStruct.new(
-    baz: ArrayOf(Integer | NilClass),
-  ); end
-
-  class Foo < TypeStruct.new(
-    nil: NilClass,
-    bar: Bar,
-  ); end
-
   BoolClass = TrueClass | FalseClass
   C = TypeStruct.new(
     a: ArrayOf(BoolClass),
@@ -124,6 +107,45 @@ module TypeStructTest
     else
       t.error("TypeError dose not raise error")
     end
+
+    hsbn = TypeStruct.new(
+      a: HashOf(Symbol, b) | NilClass,
+    )
+    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}})
+    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}")
+    else
+      t.error("Unexpected behavior")
+    end
+
+    begin
+      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
   end
 
   def test_array_of(t)
@@ -139,46 +161,147 @@ module TypeStructTest
     end
   end
 
+  def test_array_of_error(t)
+    a = TypeStruct.new(a: ArrayOf(Integer))
+    begin
+      a.from_hash(a: [1.1])
+    rescue TypeError
+    rescue => e
+      t.error("Unexpected error #{e.class}")
+    else
+      t.error("Nothing raised TypeError")
+    end
+
+    b = TypeStruct.new(a: ArrayOf(Integer) | NilClass)
+    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
+
+    c = TypeStruct.new(c: Integer)
+    d = TypeStruct.new(d: ArrayOf(c) | NilClass)
+    begin
+      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
+  end
+
   def test_s_from_hash(t)
-    foo = Foo.from_hash(bar: { baz: [1, 2, 3] })
-    unless Foo === foo
+    bar = TypeStruct.new(
+      baz: ArrayOf(Integer | NilClass),
+    )
+    foo = TypeStruct.new(
+      nil: NilClass,
+      bar: bar,
+    )
+
+    f = foo.from_hash(bar: { baz: [1, 2, 3] })
+    unless foo === f
       t.error("return value was break")
     end
 
     begin
-      Foo.from_hash(bar: { baz: [1, 2, "3"] })
-    rescue TypeError
+      foo.from_hash(bar: { baz: [1, 2, "3"] })
+    rescue TypeStruct::UnionNotFoundError
     else
       t.error("'3' is not valid value for Baz.baz:#{Bar.definition.fetch(:baz)}")
     end
 
-    foo = Foo.from_hash("bar" => { "baz" => [1, 2, 3] })
-    unless Foo === foo
+    f = foo.from_hash("bar" => { "baz" => [1, 2, 3] })
+    unless foo === f
       t.error("return value was break")
     end
 
-    foo = Foo.from_hash(bar: { baz: [1, 2, 3] }, nil: nil)
-    unless TypeStruct === foo
+    f = foo.from_hash(bar: { baz: [1, 2, 3] }, nil: nil)
+    unless TypeStruct === f
       t.error("return value type was break")
     end
-    unless Foo === foo
+    unless foo === f
       t.error("return value type was break")
     end
 
     begin
-      Foo.from_hash(bar: { baz: [1, nil, 3] })
+      foo.from_hash(bar: { baz: [1, nil, 3] })
     rescue => e
       t.error("Bar.baz is able to nil but raise error #{e.class}: #{e.message}")
     end
 
     begin
-      Foo.from_hash(bar: { baz: nil })
+      foo.from_hash(bar: { baz: nil })
     rescue TypeError
     else
       t.error("Bar.baz is not able to nil")
     end
   end
 
+  def test_s_from_hash_with_other_object(t)
+    a = TypeStruct.new(a: Integer)
+    o = Object.new
+    begin
+      a.from_hash(o)
+    rescue TypeError => e
+    rescue => e
+      t.error("Unexpected error #{e.class}")
+    else
+      t.error("should raise TypeError")
+    end
+
+    def o.to_hash
+      {a: 1}
+    end
+    unless a === a.from_hash(o)
+      t.error("Unexpected behavior")
+    end
+  end
+
+  def test_s_from_hash_with_array_of(t)
+    a = TypeStruct.new(a: ArrayOf(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}")
+      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))
+    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}")
+      end
+    rescue => e
+      t.error("Unexpected error #{e}")
+    else
+      t.error("Unexpected behavior")
+    end
+  end
+
+  def test_s_from_hash_with_not_class(t)
+    a = TypeStruct.new(a: "a")
+    begin
+      a.from_hash(a: "b")
+    rescue TypeError
+    else
+      t.error("Unexpected behavior")
+    end
+  end
+
   def test_s_from_hash_union(t)
     a = TypeStruct.new(a: Integer)
     b = TypeStruct.new(b: Integer)
@@ -186,13 +309,17 @@ module TypeStructTest
     u = TypeStruct::Union.new(a, b, c)
     d = TypeStruct.new(d: u)
 
-    d.from_hash(d: { b: 1 })
+    begin
+      d.from_hash(d: { b: 1 })
+    rescue => e
+      t.error("Unexpected error was raised #{e.class}: #{e.message}")
+    end
 
     begin
       d.from_hash(d: [b: 1])
     rescue TypeStruct::UnionNotFoundError => err
-      unless /is not found with errors/ =~ err.message
-        t.error("error message was changed")
+      unless /is not found with value/ =~ err.message
+        t.error("error message was changed: '#{err.message}'")
       end
     else
       t.error("error dose not raised")
@@ -201,7 +328,16 @@ module TypeStructTest
     begin
       d.from_hash(d: { b: "a" })
     rescue TypeStruct::UnionNotFoundError => err
-      unless /is not found with errors/ =~ err.message
+      unless /is not found with value/ =~ err.message
+        t.error("error message was changed")
+      end
+      unless /#a expect Integer got nil/ =~ err.message
+        t.error("error message was changed")
+      end
+      unless /#b expect Integer got "a"/ =~ err.message
+        t.error("error message was changed")
+      end
+      unless /#c expect Integer got nil/ =~ err.message
         t.error("error message was changed")
       end
     else
@@ -210,36 +346,51 @@ module TypeStructTest
   end
 
   def test_s_from_hash_equal(t)
-    expect = Foo.new(bar: Bar.new(baz: [1, 2, 3]))
-    actual = Foo.from_hash(bar: { baz: [1, 2, 3] })
+    bar = TypeStruct.new(
+      baz: ArrayOf(Integer | NilClass),
+    )
+    foo = TypeStruct.new(
+      nil: NilClass,
+      bar: bar,
+    )
+
+    expect = foo.new(bar: bar.new(baz: [1, 2, 3]))
+    actual = foo.from_hash(bar: { baz: [1, 2, 3] })
     if expect != actual
       t.error("expect #{expect} got #{actual}")
     end
 
-    noteq = Foo.from_hash(bar: { baz: [1, 2, 4] })
+    noteq = foo.from_hash(bar: { baz: [1, 2, 4] })
     if expect == noteq
       t.error("expect #{expect} not equal #{noteq}")
     end
 
-    noteq = Foo.from_hash(bar: { baz: [1, 2, nil] })
+    noteq = foo.from_hash(bar: { baz: [1, 2, nil] })
     if expect == noteq
       t.error("expect #{expect} not equal #{noteq}")
     end
   end
 
   def test_s_from_hash_with_struct(t)
-    qux = Qux.from_hash(quux1: { q: 1 }, quux2: { q: nil })
-    unless Qux === qux
+    quux = Struct.new(:q)
+
+    qux = TypeStruct.new(
+      quux1: quux,
+      quux2: quux,
+    )
+
+    q = qux.from_hash(quux1: { q: 1 }, quux2: { q: nil })
+    unless qux === q
       t.error("return value was break")
     end
-    unless Quux === qux.quux1
+    unless quux === q.quux1
       t.error("struct type was not applied")
     end
-    unless 1 == qux.quux1.q
-      t.error("mapping failed #{qux.quux.q} != 1")
+    unless 1 == q.quux1.q
+      t.error("mapping failed #{q.quux.q} != 1")
     end
-    unless nil == qux.quux2.q
-      t.error("mapping failed #{qux.quux.q} != nil")
+    unless nil == q.quux2.q
+      t.error("mapping failed #{q.quux.q} != nil")
     end
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: type_struct
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - ksss
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-18 00:00:00.000000000 Z
+date: 2016-03-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -76,6 +76,7 @@ files:
 - lib/type_struct/union.rb
 - lib/type_struct/union_test.rb
 - lib/type_struct/version.rb
+- lib/type_struct_benchmark_test.rb
 - lib/type_struct_test.rb
 - type_struct.gemspec
 homepage: https://github.com/ksss/type_struct