type_struct 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e2cfa24de41d389c4673dbfb4ed687240ce20657
-  data.tar.gz: 601c08537cfc0b5611c56c84dc038be39c126d07
+  metadata.gz: 7cb90a5e3baaac22f77fc721160e434f7d79a4fe
+  data.tar.gz: 5db1cae7790e5cc16b89f9d17a386e33958ad88f
 SHA512:
-  metadata.gz: 49c262034c7d567bd0a9a92750f2252d159d65d6b907cff5482fef960c4c018781e072686bb30da35630d7b54cde69b4e728cab050dfd71c76439d5fcbc3347f
-  data.tar.gz: 45c7fdf89ea4980a161cba41d09ef89fbf6375f1e25a4a7f78a00dfe2d771145e30a8da28b647330ea765dcdc220c9f37611d228dad3d5b4185253065dde8845
+  metadata.gz: 0caefd5bf92dc35fc51774741a110b8a712a97ee333a7f7fd170b0a3e90675fe02050570cb2fc452865a92985fbe8b3189dcfa3c91d473f413935e55c4e267d2
+  data.tar.gz: 3d88d07143f6455aadab4723c1e761a49b8e152c905669a9250030cce67cce2cd324e0f6c79c419467aef3ba5445d7308c5ecb3c518eecceddda022320f46c7d

data/README.md

@@ -11,12 +11,12 @@ All type is checked by `===` method.
 ### Check type
 
 ```ruby
-class Sample < TypeStruct.new(
+Sample = TypeStruct.new(
   str: String,
   reg: /exp/,
   num: Integer,
   any: Object,
-); end
+)
 
 sample = Sample.new(
   str: "instance of String",
@@ -71,6 +71,8 @@ line.stort
 
 Union is a object express class that some classes as one class like crystal `Union`.
 
+`Union#===` check all object with `===` method.
+
 ```ruby
 Foo = TypeStruct.new(
   bar: TypeStruct::Union.new(TrueClass, FalseClass)
@@ -78,11 +80,11 @@ Foo = TypeStruct.new(
 p Foo.new(bar: false) #=> #<Foo bar=false>
 ```
 
-or
+or add `Class#|` method by refinements
 
 ```ruby
 require "type_struct/ext"
-using UnionExt
+using TypeStruct::Union::Ext
 Foo = TypeStruct.new(
   bar: TrueClass | FalseClass,
 )
@@ -92,6 +94,8 @@ Foo = TypeStruct.new(
 
 ArrayOf is a object express array type.
 
+`ArrayOf#===` check all item with `===` method.
+
 ```ruby
 Bar = TypeStruct.new(
   baz: TypeStruct::ArrayOf.new(Integer),
@@ -101,6 +105,8 @@ p Bar.new(baz: [1, 2, 3]) #=> #<Bar baz=[1, 2, 3]>
 
 ### HashOf
 
+`HashOf#===` check all keys and values with `===` method.
+
 ```ruby
 Baz = TypeStruct.new(
   qux: TypeStruct::HashOf.new(String, TypeStruct::ArrayOf.new(Integer))
@@ -130,9 +136,9 @@ Foo.new(bar: 1) #=> TypeError
 
 ```ruby
 require "type_struct/ext"
-using UnionExt
+using TypeStruct::Union::Ext
 Baz = TypeStruct.new(
-  qux: ArrayOf.new(Integer | TrueClass | FalseClass) | NilClass
+  qux: ArrayOf(Integer | TrueClass | FalseClass) | NilClass
 )
 p Baz.new(qux: [1]) #=> #<AAA::Baz qux=[1]>
 p Baz.new(qux: [true, false]) #=> #<AAA::Baz qux=[true, false]>

data/lib/type_struct.rb

@@ -48,72 +48,6 @@ class TypeStruct
   end
 
   class << self
-    def try_convert(klass, value)
-      return nil unless !klass.nil? && !value.nil?
-
-      if Union === klass
-        errors = []
-        klass.each do |k|
-          t = begin
-                try_convert(k, 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
-        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
-    end
-
-    def from_hash(h)
-      args = {}
-      h.each do |key, value|
-        key = key.to_sym
-        t = type(key)
-        args[key] = try_convert(t, value)
-      end
-      new(args)
-    end
-
-    def definition
-      const_get(:DEFINITION)
-    end
-
-    def members
-      definition.keys
-    end
-
-    def type(k)
-      definition[k]
-    end
-
-    def valid?(k, v)
-      definition[k] === v
-    end
-
     alias original_new new
     def new(**args, &block)
       c = Class.new(TypeStruct) do
@@ -121,6 +55,74 @@ class TypeStruct
 
         class << self
           alias_method :new, :original_new
+
+          def from_hash(h)
+            args = {}
+            h.each do |key, value|
+              key = key.to_sym
+              t = type(key)
+              args[key] = try_convert(t, value)
+            end
+            new(args)
+          end
+
+          def definition
+            const_get(:DEFINITION)
+          end
+
+          def members
+            definition.keys
+          end
+
+          def type(k)
+            definition[k]
+          end
+
+          def valid?(k, v)
+            definition[k] === v
+          end
+
+          private
+
+          def try_convert(klass, value)
+            return nil unless !klass.nil? && !value.nil?
+
+            if Union === klass
+              errors = []
+              klass.each do |k|
+                t = begin
+                      try_convert(k, 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
+              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
+          end
         end
 
         args.each_key do |k|

data/lib/type_struct/array_of_test.rb

@@ -30,8 +30,8 @@ module ArrayOfTest
 
   def test_to_s(t)
     array_of = ArrayOf.new(Symbol)
-    expect = "TypeStruct::ArrayOf(Symbol)"
-    unless expect == array_of.to_s
+    expect = /ArrayOf\(Symbol\)/
+    unless expect =~ array_of.to_s
       t.error("to_s string was break #{expect} != #{array_of}")
     end
   end

data/lib/type_struct/ext.rb

@@ -1,15 +1,44 @@
 require "type_struct"
 
+class Object
+  ArrayOf = TypeStruct::ArrayOf
+  HashOf = TypeStruct::HashOf
+  Union = TypeStruct::Union
+  Interface = TypeStruct::Interface
+end
+
 class TypeStruct
-  module UnionExt
-    refine Class do
-      include Unionable
+  class ArrayOf
+    def to_s
+      "#{self.class.name.split('::').last}(#{@type})"
+    end
+  end
+
+  class HashOf
+    def to_s
+      "#{self.class.name.split('::').last}(#{@key_type}, #{@value_type})"
+    end
+  end
+
+  class Interface
+    def to_s
+      "#<#{self.class.name.split('::').last}(#{@methods.map(&:inspect).join(',')})>"
+    end
+  end
+
+  class Union
+    def to_s
+      "#<#{self.class.name.split('::').last} #{@classes.join('|')}>"
     end
   end
 end
 
-ArrayOf = TypeStruct::ArrayOf
-HashOf = TypeStruct::HashOf
-Union = TypeStruct::Union
-UnionExt = TypeStruct::UnionExt
-Interface = TypeStruct::Interface
+module Kernel
+  def ArrayOf(klass)
+    ArrayOf.new(klass)
+  end
+
+  def HashOf(key_class, value_class)
+    HashOf.new(key_class, value_class)
+  end
+end

data/lib/type_struct/hash_of_test.rb

@@ -33,8 +33,8 @@ module HashOfTest
 
   def test_to_s(t)
     hash_of = HashOf.new(Symbol, Integer)
-    expect = "TypeStruct::HashOf(Symbol, Integer)"
-    unless expect == hash_of.to_s
+    expect = /HashOf\(Symbol, Integer\)/
+    unless expect =~ hash_of.to_s
       t.error("to_s string was break #{expect} != #{hash_of}")
     end
   end

data/lib/type_struct/union.rb

@@ -1,14 +1,21 @@
-require "forwardable"
-
 class TypeStruct
+  module Unionable
+    def |(other)
+      Union.new(self, other)
+    end
+  end
+
   class Union
-    extend Forwardable
-    def_delegators :@classes, :each
     include Enumerable
+
     def initialize(*classes)
       @classes = classes
     end
 
+    def each(*args, &block)
+      @classes.each(*args, &block)
+    end
+
     def |(other)
       Union.new(*@classes, other)
     end
@@ -21,11 +28,11 @@ class TypeStruct
       "#<#{self.class} #{@classes.join('|')}>"
     end
     alias inspect to_s
-  end
 
-  module Unionable
-    def |(other)
-      Union.new(self, other)
+    module Ext
+      refine Class do
+        include Unionable
+      end
     end
   end
 end

data/lib/type_struct/union_test.rb

@@ -41,7 +41,7 @@ module UnionTest
     t.error("refinents miss")
   end
 
-  using UnionExt
+  using TypeStruct::Union::Ext
 
   def test_class_or(t)
     u = TrueClass | FalseClass

data/lib/type_struct/version.rb

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

data/lib/type_struct_test.rb

@@ -2,13 +2,13 @@ require "type_struct"
 require "type_struct/ext"
 
 module TypeStructTest
-  using UnionExt
+  using TypeStruct::Union::Ext
 
   class Dummy < TypeStruct.new(
     str: String,
     num: Integer,
     reg: /abc/,
-    ary: ArrayOf.new(Integer | Float) | NilClass,
+    ary: ArrayOf(Integer | Float) | NilClass,
     any: Object,
   ); end
 
@@ -21,7 +21,7 @@ module TypeStructTest
   ); end
 
   class Bar < TypeStruct.new(
-    baz: ArrayOf.new(Integer | NilClass),
+    baz: ArrayOf(Integer | NilClass),
   ); end
 
   class Foo < TypeStruct.new(
@@ -31,22 +31,22 @@ module TypeStructTest
 
   BoolClass = TrueClass | FalseClass
   C = TypeStruct.new(
-    a: ArrayOf.new(BoolClass),
+    a: ArrayOf(BoolClass),
   )
   B = TypeStruct.new(
     a: Integer,
     b: BoolClass,
-    c: ArrayOf.new(Integer),
-    d: ArrayOf.new(BoolClass),
+    c: ArrayOf(Integer),
+    d: ArrayOf(BoolClass),
     e: C,
   )
   A = TypeStruct.new(
-    a: ArrayOf.new(Integer),
-    b: ArrayOf.new(BoolClass),
+    a: ArrayOf(Integer),
+    b: ArrayOf(BoolClass),
     c: BoolClass,
     d: B,
-    e: ArrayOf.new(B),
-    f: HashOf.new(String, Integer),
+    e: ArrayOf(B),
+    f: HashOf(String, Integer),
   )
 
   def test_s_from_hash_a(t)
@@ -92,7 +92,7 @@ module TypeStructTest
   def test_hash_of(t)
     b = TypeStruct.new(b: Integer)
     hc = TypeStruct.new(
-      a: HashOf.new(Symbol, b),
+      a: HashOf(Symbol, b),
     )
 
     h = hc.new(
@@ -102,7 +102,6 @@ module TypeStructTest
       t.error("assign failed")
     end
 
-    p HashOf.new(Symbol, b) === []
     begin
       hc.new(
         a: [],
@@ -129,7 +128,7 @@ module TypeStructTest
 
   def test_array_of(t)
     a = TypeStruct.new(a: Integer)
-    b = TypeStruct.new(a: ArrayOf.new(a))
+    b = TypeStruct.new(a: ArrayOf(a))
     bb = b.new(a: [a.new(a: 1), a.new(a: 2), a.new(a: 3)])
     unless b === bb
       t.error("type error")
@@ -191,14 +190,20 @@ module TypeStructTest
 
     begin
       d.from_hash(d: [b: 1])
-    rescue TypeStruct::UnionNotFoundError
+    rescue TypeStruct::UnionNotFoundError => err
+      unless /is not found with errors/ =~ err.message
+        t.error("error message was changed")
+      end
     else
       t.error("error dose not raised")
     end
 
     begin
       d.from_hash(d: { b: "a" })
-    rescue TypeStruct::UnionNotFoundError
+    rescue TypeStruct::UnionNotFoundError => err
+      unless /is not found with errors/ =~ err.message
+        t.error("error message was changed")
+      end
     else
       t.error("error dose not raised")
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: type_struct
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - ksss
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-15 00:00:00.000000000 Z
+date: 2016-03-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -98,7 +98,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.2
+rubygems_version: 2.6.1
 signing_key: 
 specification_version: 4
 summary: Imitating static typed struct.