type_struct 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e4ad3ee2f907ec9b4607626b3708183e99d97a6a
-  data.tar.gz: 55840f29943e7263fd0671eca5fd00286f765673
+  metadata.gz: e2cfa24de41d389c4673dbfb4ed687240ce20657
+  data.tar.gz: 601c08537cfc0b5611c56c84dc038be39c126d07
 SHA512:
-  metadata.gz: 66b8e9b9a352b38f9751e65bd933ccc7dc477dcdc49a6c12e51cf7ea5e0377f6e608f4fbca3f9758cc679ee8d38a761102ee1d53b333039032af4ad2106bf7ab
-  data.tar.gz: b5d4fb2c7980a1ca40fbb463a224d079b11bc95683ff5bca68b0fb2655ad22360d89b17d33c09f9a78b5aa1fdf41d2f8dde4f07e3b8f7a7e8980ab551761f901
+  metadata.gz: 49c262034c7d567bd0a9a92750f2252d159d65d6b907cff5482fef960c4c018781e072686bb30da35630d7b54cde69b4e728cab050dfd71c76439d5fcbc3347f
+  data.tar.gz: 45c7fdf89ea4980a161cba41d09ef89fbf6375f1e25a4a7f78a00dfe2d771145e30a8da28b647330ea765dcdc220c9f37611d228dad3d5b4185253065dde8845

data/README.md

@@ -4,6 +4,8 @@
 
 Imitating static typed struct.
 
+All type is checked by `===` method.
+
 ## Usage
 
 ### Check type
@@ -38,6 +40,8 @@ sample.str = 1 #=> TypeError
 
 ### Mapping from Hash
 
+Generate object from hash recursive
+
 ```ruby
 Point = TypeStruct.new(
   x: Integer,
@@ -61,14 +65,15 @@ line.stort
 #=> NoMethodError
 ```
 
-## Two special notation
+## Four special notation
 
 ### Union
 
+Union is a object express class that some classes as one class like crystal `Union`.
+
 ```ruby
-require "union"
 Foo = TypeStruct.new(
-  bar: Union.new(TrueClass, FalseClass)
+  bar: TypeStruct::Union.new(TrueClass, FalseClass)
 )
 p Foo.new(bar: false) #=> #<Foo bar=false>
 ```
@@ -76,7 +81,7 @@ p Foo.new(bar: false) #=> #<Foo bar=false>
 or
 
 ```ruby
-require "union_ext"
+require "type_struct/ext"
 using UnionExt
 Foo = TypeStruct.new(
   bar: TrueClass | FalseClass,
@@ -85,16 +90,46 @@ Foo = TypeStruct.new(
 
 ### ArrayOf
 
+ArrayOf is a object express array type.
+
 ```ruby
 Bar = TypeStruct.new(
-  baz: ArrayOf.new(Integer),
+  baz: TypeStruct::ArrayOf.new(Integer),
 )
 p Bar.new(baz: [1, 2, 3]) #=> #<Bar baz=[1, 2, 3]>
 ```
 
+### HashOf
+
+```ruby
+Baz = TypeStruct.new(
+  qux: TypeStruct::HashOf.new(String, TypeStruct::ArrayOf.new(Integer))
+)
+p Baz.new(qux: { "a" => [1, 2, 3] }) #=> #<Baz qux={"a"=>[1, 2, 3]}>
+p Baz.from_hash(qux: { "a" => [1, 2, 3] }) #<Baz qux={"a"=>[1, 2, 3]}>
+p Baz.new(qux: { :a  => [1, 2, 3] }) #=> TypeError
+p Baz.new(qux: { "a" => [1, 2, nil] }) #=> TypeError
+```
+
+### Interface
+
+Interface is a object for duck typing like golang `interface`.
+
+`Interface#===` check all method using `respond_to?`
+
+```ruby
+Foo = TypeStruct.new(
+  bar: TypeStruct::Interface.new(:read, :write)
+  # or Interface.new(:read, :write) on required 'type_struct/ext'
+)
+Foo.new(bar: $stdin)
+Foo.new(bar: 1) #=> TypeError
+```
+
 ### Mix
 
 ```ruby
+require "type_struct/ext"
 using UnionExt
 Baz = TypeStruct.new(
   qux: ArrayOf.new(Integer | TrueClass | FalseClass) | NilClass
@@ -103,6 +138,7 @@ p Baz.new(qux: [1]) #=> #<AAA::Baz qux=[1]>
 p Baz.new(qux: [true, false]) #=> #<AAA::Baz qux=[true, false]>
 p Baz.new(qux: nil) #=> #<AAA::Baz qux=nil>
 p Baz.new(qux: 1) #=> TypeError
+p Baz.from_hash(qux: [1, 2, false, true]) #=> #<A::Baz qux=[1, 2, false, true]>
 ```
 
 ## Installation

data/lib/type_struct.rb

@@ -1,11 +1,11 @@
-require "type_struct/union"
-require "type_struct/arrayof"
-
 class TypeStruct
+  require "type_struct/union"
+  require "type_struct/array_of"
+  require "type_struct/hash_of"
+  require "type_struct/interface"
   require "type_struct/version"
 
-  class NoMemberError < StandardError
-  end
+  UnionNotFoundError = Class.new(StandardError)
 
   def initialize(arg)
     sym_arg = {}
@@ -37,6 +37,7 @@ class TypeStruct
     end
     "#<#{self.class} #{m.join(', ')}>"
   end
+  alias to_s inspect
 
   def to_h
     m = {}
@@ -48,27 +49,43 @@ class TypeStruct
 
   class << self
     def try_convert(klass, value)
-      return nil unless klass
+      return nil unless !klass.nil? && !value.nil?
 
       if Union === klass
+        errors = []
         klass.each do |k|
-          t = try_convert(k, value)
+          t = begin
+                try_convert(k, value)
+              rescue TypeError => e
+                errors << e
+                nil
+              end
           return t if !t.nil?
         end
-        nil
+        raise UnionNotFoundError, "#{klass} is not found with errors:\n#{errors.join("\n")}"
       elsif ArrayOf === klass
         value.map { |v| try_convert(klass.type, v) }
-      elsif 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 HashOf === klass
+        return value unless Hash === value
+        new_hash = {}
+        value.each do |hk, hv|
+          new_hash[hk] = try_convert(klass.value_type, 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
+          value
+        end
       else
         value
       end
-    rescue
-      nil
     end
 
     def from_hash(h)
@@ -76,28 +93,7 @@ class TypeStruct
       h.each do |key, value|
         key = key.to_sym
         t = type(key)
-        if Class === t
-          case
-          when t.ancestors.include?(TypeStruct)
-            args[key] = t.from_hash(value)
-          when t.ancestors.include?(Struct)
-            struct = t.new
-            value.each { |k, v| struct[k] = v }
-            args[key] = struct
-          when t.respond_to?(:new)
-            args[key] = t.new(value)
-          else
-            args[key] = value
-          end
-        elsif ArrayOf === t
-          args[key] = if value.respond_to?(:map)
-            value.map { |v| try_convert(t.type, v) }
-          else
-            value
-          end
-        else
-          args[key] = try_convert(t, value)
-        end
+        args[key] = try_convert(t, value)
       end
       new(args)
     end
@@ -111,26 +107,11 @@ class TypeStruct
     end
 
     def type(k)
-      t = definition[k]
-      if Hash === t
-        t[:type]
-      else
-        t
-      end
+      definition[k]
     end
 
     def valid?(k, v)
-      t = definition[k]
-      if ArrayOf === t && Array === v
-        v.all? { |vv| t.type === vv }
-      elsif Array === t
-        return false if v.nil?
-        v.all? { |i| t.any? { |c| c === i } }
-      elsif TypeStruct === v
-        t == v.class
-      else
-        t === v
-      end
+      definition[k] === v
     end
 
     alias original_new new
@@ -142,13 +123,12 @@ class TypeStruct
           alias_method :new, :original_new
         end
 
-        args.each do |k, _|
+        args.each_key do |k|
           define_method(k) do
             instance_variable_get("@#{k}")
           end
 
           define_method("#{k}=") do |v|
-            raise TypeStruct::NoMemberError unless respond_to?(k)
             unless self.class.valid?(k, v)
               raise TypeError, "#{self.class}##{k} expect #{self.class.type(k)} got #{v.inspect}"
             end

data/lib/type_struct/{arrayof.rb → array_of.rb}

@@ -2,23 +2,20 @@ require "type_struct/union"
 
 class TypeStruct
   class ArrayOf
+    include Unionable
     attr_reader :type
     def initialize(type)
       @type = type
     end
 
-    def |(other)
-      Union.new(self, other)
-    end
-
     def to_s
-      "#<#{self.class} #{@type}>"
+      "#{self.class}(#{@type})"
     end
     alias inspect to_s
 
     def ===(other)
-      return false unless other.respond_to?(:any?)
-      other.any? { |o| @type === o }
+      return false unless Array === other
+      other.all? { |o| @type === o }
     end
   end
 end

data/lib/type_struct/array_of_test.rb

@@ -0,0 +1,38 @@
+require "type_struct/array_of"
+
+module ArrayOfTest
+  def test_initialize(t)
+    unless ArrayOf === ArrayOf.new(Integer)
+      t.error("failed when array of integer")
+    end
+  end
+
+  def test_equal(t)
+    int = ArrayOf.new(Integer)
+    str = ArrayOf.new(String)
+
+    unless int === []
+      t.error("empty array check was failed")
+    end
+
+    unless int === [1, 2, 3]
+      t.error("array of integer check was failed")
+    end
+
+    unless str === %w(foo bar baz)
+      t.error("array of string check was failed")
+    end
+
+    if str === [1, 2, 3]
+      t.error("array of integer is not string")
+    end
+  end
+
+  def test_to_s(t)
+    array_of = ArrayOf.new(Symbol)
+    expect = "TypeStruct::ArrayOf(Symbol)"
+    unless expect == array_of.to_s
+      t.error("to_s string was break #{expect} != #{array_of}")
+    end
+  end
+end

data/lib/type_struct/ext.rb

@@ -1,16 +1,15 @@
-require "type_struct/union"
-require "type_struct/arrayof"
+require "type_struct"
 
 class TypeStruct
   module UnionExt
     refine Class do
-      def |(other)
-        Union.new(self, other)
-      end
+      include Unionable
     end
   end
 end
 
 ArrayOf = TypeStruct::ArrayOf
+HashOf = TypeStruct::HashOf
 Union = TypeStruct::Union
 UnionExt = TypeStruct::UnionExt
+Interface = TypeStruct::Interface

data/lib/type_struct/hash_of.rb

@@ -0,0 +1,24 @@
+require "type_struct/union"
+
+class TypeStruct
+  class HashOf
+    include Unionable
+
+    attr_reader :key_type, :value_type
+    def initialize(key_type, value_type)
+      @key_type = key_type
+      @value_type = value_type
+    end
+
+    def ===(other)
+      return false unless Hash === other
+      other.all? do |k, v|
+        @key_type === k && @value_type === v
+      end
+    end
+
+    def to_s
+      "#{self.class}(#{@key_type}, #{@value_type})"
+    end
+  end
+end

data/lib/type_struct/hash_of_test.rb

@@ -0,0 +1,41 @@
+require "type_struct/hash_of"
+
+module HashOfTest
+  def test_initialize(t)
+    unless HashOf === HashOf.new(String, String)
+      t.error("make hash of")
+    end
+  end
+
+  def test_equal(t)
+    ssh = HashOf.new(String, String)
+    unless ssh === { "a" => "b", "c" => "d" }
+      t.error("=== equal check failed")
+    end
+    if ssh === { "a" => "b", "c" => :d }
+      t.error("=== equal check failed")
+    end
+    if ssh === { "a" => "b", :c => "d" }
+      t.error("=== equal check failed")
+    end
+
+    ifh = HashOf.new(Integer, Float)
+    unless ifh === { 1 => 1.0, 2 => Float::NAN }
+      t.error("=== equal check failed")
+    end
+    if ifh === { 1 => 1, 2 => Float::NAN }
+      t.error("=== equal check failed")
+    end
+    if ifh === { 1 => 1.0, "2" => "1" }
+      t.error("=== equal check failed")
+    end
+  end
+
+  def test_to_s(t)
+    hash_of = HashOf.new(Symbol, Integer)
+    expect = "TypeStruct::HashOf(Symbol, Integer)"
+    unless expect == hash_of.to_s
+      t.error("to_s string was break #{expect} != #{hash_of}")
+    end
+  end
+end

data/lib/type_struct/interface.rb

@@ -0,0 +1,35 @@
+require "type_struct/union"
+
+class TypeStruct
+  # IOLike = TypeStruct::Interface.new(
+  #   :read,
+  #   :write,
+  #   :close,
+  #   :closed?
+  # )
+  # IOLike === StringIO.new #=> true
+  # IOLike === $stdin       #=> true
+  # IOLike === 1            #=> false
+  # IOLike === "io"         #=> false
+  #
+  # case $stdin
+  # when IOLike
+  #   puts "this is a io like object!"
+  # end
+  class Interface
+    include Unionable
+    def initialize(*methods)
+      @methods = methods
+    end
+
+    def ===(other)
+      @methods.all? do |m|
+        other.respond_to?(m)
+      end
+    end
+
+    def to_s
+      "#<#{self.class}(#{@methods.map(&:inspect).join(',')})>"
+    end
+  end
+end

data/lib/type_struct/interface_test.rb

@@ -0,0 +1,58 @@
+require "type_struct/interface"
+
+module InterfaceTest
+  Interface = TypeStruct::Interface
+  def test_initialize(t)
+    unless Interface === Interface.new
+      t.error("return value was break")
+    end
+    unless Interface === Interface.new(:foo)
+      t.error("return value was break")
+    end
+    unless Interface === Interface.new(:foo, :bar)
+      t.error("return value was break")
+    end
+  end
+
+  Reader = Interface.new(:read)
+  Writer = Interface.new(:write)
+  ReadWriter = Interface.new(:read, :write)
+
+  def test_equal(t)
+    r = Object.new
+    def r.read
+    end
+    case r
+    when Reader
+    else
+      t.error("expect Reader === r is true")
+    end
+
+    w = Object.new
+    def w.write
+    end
+    case w
+    when Writer
+    else
+      t.error("expect Writer === w is true")
+    end
+
+    case r
+    when ReadWriter
+      t.error("expect ReadWriter === r is false")
+    end
+  end
+
+  def test_or(t)
+    r_or_w = Reader | Writer
+    r = Object.new
+    def r.read
+    end
+
+    case r
+    when r_or_w
+    else
+      t.error("expect rw === r is true")
+    end
+  end
+end

data/lib/type_struct/union.rb

@@ -22,4 +22,10 @@ class TypeStruct
     end
     alias inspect to_s
   end
+
+  module Unionable
+    def |(other)
+      Union.new(self, other)
+    end
+  end
 end

data/lib/type_struct/union_test.rb

@@ -34,6 +34,13 @@ module UnionTest
     end
   end
 
+  def test_class_or_is_undefined(t)
+    TrueClass | FalseClass
+  rescue NoMethodError
+  else
+    t.error("refinents miss")
+  end
+
   using UnionExt
 
   def test_class_or(t)

data/lib/type_struct/version.rb

@@ -1,3 +1,3 @@
 class TypeStruct
-  VERSION = "0.2.1"
+  VERSION = "0.3.0"
 end

data/lib/type_struct_test.rb

@@ -46,6 +46,7 @@ module TypeStructTest
     c: BoolClass,
     d: B,
     e: ArrayOf.new(B),
+    f: HashOf.new(String, Integer),
   )
 
   def test_s_from_hash_a(t)
@@ -59,28 +60,102 @@ module TypeStructTest
         { a: 2, b: true, c: [1, 2, 3], d: [false], e: { a: [true] } },
         { a: 3, b: true, c: [1, 2, 3], d: [false], e: { a: [true] } },
       ],
+      f: {
+        "a" => 1,
+        "c" => 2,
+      },
+    )
+    aa = A.new(
+      a: [1, 2, 3],
+      b: [false, true, false],
+      c: false,
+      d: B.new(a: 1, b: false, c: [1, 2, 3], d: [false], e: C.new(a: [true])),
+      e: [
+        B.new(a: 1, b: false, c: [1, 2, 3], d: [false], e: C.new(a: [true])),
+        B.new(a: 2, b: true, c: [1, 2, 3], d: [false], e: C.new(a: [true])),
+        B.new(a: 3, b: true, c: [1, 2, 3], d: [false], e: C.new(a: [true])),
+      ],
+      f: {
+        "a" => 1,
+        "c" => 2,
+      },
     )
     unless A === a
-      t.error("failed")
+      t.error("instance type miss")
+    end
+
+    unless a == aa
+      t.error("not same new and from_hash")
     end
   end
 
-  def test_s_from_hash(t)
-    foo = Foo.from_hash(bar: { baz: [1, 2, 3] })
-    unless Foo === foo
-      t.error("return value was break")
+  def test_hash_of(t)
+    b = TypeStruct.new(b: Integer)
+    hc = TypeStruct.new(
+      a: HashOf.new(Symbol, b),
+    )
+
+    h = hc.new(
+      a: { sym: b.new(b: 1) },
+    )
+    unless 1 === h.a[:sym].b
+      t.error("assign failed")
     end
 
-    foo = Foo.from_hash("bar" => { "baz" => [1, 2, 3] })
+    p HashOf.new(Symbol, b) === []
+    begin
+      hc.new(
+        a: [],
+      )
+    rescue TypeError
+    else
+      t.error("TypeError was not railsed")
+    end
+
+    hh = hc.from_hash(
+      a: { sym: { b: 1 } },
+    )
+    unless hh == h
+      t.error("new and from_hash dose not make equal object")
+    end
+
+    begin
+      hh = hc.from_hash(a: 1)
+    rescue TypeError
+    else
+      t.error("TypeError dose not raise error")
+    end
+  end
+
+  def test_array_of(t)
+    a = TypeStruct.new(a: Integer)
+    b = TypeStruct.new(a: ArrayOf.new(a))
+    bb = b.new(a: [a.new(a: 1), a.new(a: 2), a.new(a: 3)])
+    unless b === bb
+      t.error("type error")
+    end
+
+    unless bb == b.from_hash(a: [{ a: 1 }, { a: 2 }, { a: 3 }])
+      t.error("from_hash error")
+    end
+  end
+
+  def test_s_from_hash(t)
+    foo = Foo.from_hash(bar: { baz: [1, 2, 3] })
     unless Foo === foo
       t.error("return value was break")
     end
 
     begin
-      Foo.from_hash(bar: { baz: [1, 2, 3] }, nil: 1)
+      Foo.from_hash(bar: { baz: [1, 2, "3"] })
     rescue TypeError
     else
-      t.error("Bar.qux is not able to nil but accepted")
+      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
+      t.error("return value was break")
     end
 
     foo = Foo.from_hash(bar: { baz: [1, 2, 3] }, nil: nil)
@@ -105,6 +180,30 @@ module TypeStructTest
     end
   end
 
+  def test_s_from_hash_union(t)
+    a = TypeStruct.new(a: Integer)
+    b = TypeStruct.new(b: Integer)
+    c = TypeStruct.new(c: Integer)
+    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 TypeStruct::UnionNotFoundError
+    else
+      t.error("error dose not raised")
+    end
+
+    begin
+      d.from_hash(d: { b: "a" })
+    rescue TypeStruct::UnionNotFoundError
+    else
+      t.error("error dose not raised")
+    end
+  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] })

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: type_struct
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - ksss
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-06 00:00:00.000000000 Z
+date: 2016-02-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -66,8 +66,13 @@ files:
 - README.md
 - Rakefile
 - lib/type_struct.rb
-- lib/type_struct/arrayof.rb
+- lib/type_struct/array_of.rb
+- lib/type_struct/array_of_test.rb
 - lib/type_struct/ext.rb
+- lib/type_struct/hash_of.rb
+- lib/type_struct/hash_of_test.rb
+- lib/type_struct/interface.rb
+- lib/type_struct/interface_test.rb
 - lib/type_struct/union.rb
 - lib/type_struct/union_test.rb
 - lib/type_struct/version.rb
@@ -93,7 +98,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
 summary: Imitating static typed struct.