type_struct 0.1.1 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a27067e9d45914510c4dc7ac39e5927ac10169e4
-  data.tar.gz: 55b6804d69ca33abed2512f981262bf4131640e6
+  metadata.gz: e4ad3ee2f907ec9b4607626b3708183e99d97a6a
+  data.tar.gz: 55840f29943e7263fd0671eca5fd00286f765673
 SHA512:
-  metadata.gz: 69fa0b767895bb4acfc900ee449c7c7c364f37dcdfadeb9d355ecf6bfec8aa18d360ead266e728143c7760b27118c6e20ea0d960a176c31168c51d9279faa6ec
-  data.tar.gz: 1360dc44909bb05bda962e05e2705406381af5f017044d411e6afb954c8415d84dd2e85beeeba412fdecb82ed491d2fa6d215273ff5a965b36efa540156fdcbe
+  metadata.gz: 66b8e9b9a352b38f9751e65bd933ccc7dc477dcdc49a6c12e51cf7ea5e0377f6e608f4fbca3f9758cc679ee8d38a761102ee1d53b333039032af4ad2106bf7ab
+  data.tar.gz: b5d4fb2c7980a1ca40fbb463a224d079b11bc95683ff5bca68b0fb2655ad22360d89b17d33c09f9a78b5aa1fdf41d2f8dde4f07e3b8f7a7e8980ab551761f901

data/.travis.yml

@@ -1,8 +1,8 @@
 language: ruby
 rvm:
-  - 2.0.0
-  - 2.1.7
-  - 2.2.3
+  - 2.1.8
+  - 2.2.4
+  - 2.3.0
 before_install: gem install bundler -v 1.10.6
 notifications:
   email: false

data/README.md

@@ -6,6 +6,8 @@ Imitating static typed struct.
 
 ## Usage
 
+### Check type
+
 ```ruby
 class Sample < TypeStruct.new(
   str: String,
@@ -26,6 +28,81 @@ p sample
 
 p sample.to_h
 #=> {:str=>"instance of String", :reg=>"not match to regexp", :num=>10, :any=>true}
+
+p sample.str
+#=> "instance of String"
+
+sample.string #=> NoMethodError
+sample.str = 1 #=> TypeError
+```
+
+### Mapping from Hash
+
+```ruby
+Point = TypeStruct.new(
+  x: Integer,
+  y: Integer,
+)
+Color = Struct.new(:code)
+Line = TypeStruct.new(
+  start: Point,
+  end: Point,
+  color: Color,
+)
+
+hash = JSON.parse(%({"start":{"x":3,"y":10},"end":{"x":5,"y":9},"color":{"code":"#CAFE00"}}))
+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">>
+p line.start.y
+#=> 10
+line.stort
+#=> NoMethodError
+```
+
+## Two special notation
+
+### Union
+
+```ruby
+require "union"
+Foo = TypeStruct.new(
+  bar: Union.new(TrueClass, FalseClass)
+)
+p Foo.new(bar: false) #=> #<Foo bar=false>
+```
+
+or
+
+```ruby
+require "union_ext"
+using UnionExt
+Foo = TypeStruct.new(
+  bar: TrueClass | FalseClass,
+)
+```
+
+### ArrayOf
+
+```ruby
+Bar = TypeStruct.new(
+  baz: ArrayOf.new(Integer),
+)
+p Bar.new(baz: [1, 2, 3]) #=> #<Bar baz=[1, 2, 3]>
+```
+
+### Mix
+
+```ruby
+using UnionExt
+Baz = TypeStruct.new(
+  qux: ArrayOf.new(Integer | TrueClass | FalseClass) | NilClass
+)
+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
 ```
 
 ## Installation

data/lib/type_struct.rb

@@ -1,29 +1,148 @@
+require "type_struct/union"
+require "type_struct/arrayof"
+
 class TypeStruct
   require "type_struct/version"
 
   class NoMemberError < StandardError
   end
 
+  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]
+    end
+  end
+
+  def ==(other)
+    return false unless TypeStruct === other
+    return false unless to_h == other.to_h
+    true
+  end
+
+  def []=(k, v)
+    __send__("#{k}=", v)
+  end
+
+  def [](k)
+    __send__(k)
+  end
+
+  def inspect
+    m = to_h.map do |k, v|
+      "#{k}=#{v.inspect}"
+    end
+    "#<#{self.class} #{m.join(', ')}>"
+  end
+
+  def to_h
+    m = {}
+    self.class.members.each do |k|
+      m[k] = self[k]
+    end
+    m
+  end
+
   class << self
-    def new(**args)
-      Class.new do
-        const_set :MEMBERS, args
+    def try_convert(klass, value)
+      return nil unless klass
 
-        class << self
-          def members
-            const_get(:MEMBERS)
-          end
+      if Union === klass
+        klass.each do |k|
+          t = try_convert(k, value)
+          return t if !t.nil?
+        end
+        nil
+      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
+      else
+        value
+      end
+    rescue
+      nil
+    end
 
-          def type(k)
-            members[k]
+    def from_hash(h)
+      args = {}
+      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
-
-          def valid?(k, v)
-            type(k) === v
+        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
+      end
+      new(args)
+    end
+
+    def definition
+      const_get(:DEFINITION)
+    end
 
-        args.keys.each do |k, _|
+    def members
+      definition.keys
+    end
+
+    def type(k)
+      t = definition[k]
+      if Hash === t
+        t[:type]
+      else
+        t
+      end
+    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
+    end
+
+    alias original_new new
+    def new(**args, &block)
+      c = Class.new(TypeStruct) do
+        const_set :DEFINITION, args
+
+        class << self
+          alias_method :new, :original_new
+        end
+
+        args.each do |k, _|
           define_method(k) do
             instance_variable_get("@#{k}")
           end
@@ -31,42 +150,16 @@ class TypeStruct
           define_method("#{k}=") do |v|
             raise TypeStruct::NoMemberError unless respond_to?(k)
             unless self.class.valid?(k, v)
-              raise TypeError, "expect #{self.class.type(k)} got #{v.class}"
+              raise TypeError, "#{self.class}##{k} expect #{self.class.type(k)} got #{v.inspect}"
             end
             instance_variable_set("@#{k}", v)
           end
         end
-
-        def initialize(**arg)
-          self.class.members.each do |k, _|
-            self[k] = arg[k]
-          end
-        end
-
-        def []=(k, v)
-          __send__("#{k}=", v)
-        end
-
-        def [](k)
-          __send__(k)
-        end
-
-        def inspect
-          m = to_h.map do |k, v|
-            "#{k}=#{v.inspect}"
-          end
-          "#<#{self.class.to_s} #{m.join(', ')}>"
-        end
-
-        def to_h
-          m = {}
-          self.class.members.each do |k, _|
-            m[k] = self[k]
-          end
-          m
-        end
-        alias to_hash to_h
       end
+      if block_given?
+        c.module_eval(&block)
+      end
+      c
     end
   end
 end

data/lib/type_struct/arrayof.rb

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

data/lib/type_struct/ext.rb

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

data/lib/type_struct/union.rb

@@ -0,0 +1,25 @@
+require "forwardable"
+
+class TypeStruct
+  class Union
+    extend Forwardable
+    def_delegators :@classes, :each
+    include Enumerable
+    def initialize(*classes)
+      @classes = classes
+    end
+
+    def |(other)
+      Union.new(*@classes, other)
+    end
+
+    def ===(other)
+      @classes.any? { |c| c === other }
+    end
+
+    def to_s
+      "#<#{self.class} #{@classes.join('|')}>"
+    end
+    alias inspect to_s
+  end
+end

data/lib/type_struct/union_test.rb

@@ -0,0 +1,45 @@
+require "type_struct/ext"
+
+module UnionTest
+  U = Union.new(TrueClass, FalseClass)
+  def test_union(t)
+    unless Union === U
+      t.error("union error")
+    end
+  end
+
+  def test_or(t)
+    if U === nil
+      t.error("nil")
+    end
+
+    n = U | NilClass
+    if U === nil
+      t.error("nil")
+    end
+    unless n === nil
+      t.error("nil")
+    end
+  end
+
+  def test_equal(t)
+    unless U === true
+      t.error("union error")
+    end
+    unless U === false
+      t.error("union error")
+    end
+    if U === nil
+      t.error("union error")
+    end
+  end
+
+  using UnionExt
+
+  def test_class_or(t)
+    u = TrueClass | FalseClass
+    unless u === true
+      t.error("error")
+    end
+  end
+end

data/lib/type_struct/version.rb

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

data/lib/type_struct_test.rb

@@ -1,26 +1,161 @@
-require 'type_struct'
+require "type_struct"
+require "type_struct/ext"
 
 module TypeStructTest
+  using UnionExt
+
   class Dummy < TypeStruct.new(
     str: String,
     num: Integer,
     reg: /abc/,
+    ary: ArrayOf.new(Integer | Float) | NilClass,
     any: Object,
   ); end
 
+  class Quux < Struct.new(:q)
+  end
+
+  class Qux < TypeStruct.new(
+    quux1: Quux,
+    quux2: Quux,
+  ); end
+
+  class Bar < TypeStruct.new(
+    baz: ArrayOf.new(Integer | NilClass),
+  ); end
+
+  class Foo < TypeStruct.new(
+    nil: NilClass,
+    bar: Bar,
+  ); end
+
+  BoolClass = TrueClass | FalseClass
+  C = TypeStruct.new(
+    a: ArrayOf.new(BoolClass),
+  )
+  B = TypeStruct.new(
+    a: Integer,
+    b: BoolClass,
+    c: ArrayOf.new(Integer),
+    d: ArrayOf.new(BoolClass),
+    e: C,
+  )
+  A = TypeStruct.new(
+    a: ArrayOf.new(Integer),
+    b: ArrayOf.new(BoolClass),
+    c: BoolClass,
+    d: B,
+    e: ArrayOf.new(B),
+  )
+
+  def test_s_from_hash_a(t)
+    a = A.from_hash(
+      a: [1, 2, 3],
+      b: [false, true, false],
+      c: false,
+      d: { a: 1, b: false, c: [1, 2, 3], d: [false], e: { a: [true] } },
+      e: [
+        { a: 1, b: false, c: [1, 2, 3], d: [false], e: { a: [true] } },
+        { 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] } },
+      ],
+    )
+    unless A === a
+      t.error("failed")
+    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
+
+    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)
+    rescue TypeError
+    else
+      t.error("Bar.qux is not able to nil but accepted")
+    end
+
+    foo = Foo.from_hash(bar: { baz: [1, 2, 3] }, nil: nil)
+    unless TypeStruct === foo
+      t.error("return value type was break")
+    end
+    unless Foo === foo
+      t.error("return value type was break")
+    end
+
+    begin
+      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 })
+    rescue TypeError
+    else
+      t.error("Bar.baz is not able to nil")
+    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] })
+    if expect != actual
+      t.error("expect #{expect} got #{actual}")
+    end
+
+    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] })
+    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
+      t.error("return value was break")
+    end
+    unless Quux === qux.quux1
+      t.error("struct type was not applied")
+    end
+    unless 1 == qux.quux1.q
+      t.error("mapping failed #{qux.quux.q} != 1")
+    end
+    unless nil == qux.quux2.q
+      t.error("mapping failed #{qux.quux.q} != nil")
+    end
+  end
+
   def test_s_members(t)
     m = Dummy.members
-    expect = {str: String, num: Integer, reg: /abc/, any: Object}
+    expect = [:str, :num, :reg, :ary, :any]
     unless m == expect
       t.error("expect #{expect} got #{m}")
     end
   end
 
   def test_s_type(t)
-    m = Dummy.members
-    m.each do |k, v|
-      unless Dummy.type(k) == v
-        t.error("expect #{v} got #{Dummy.type(k)}")
+    Dummy.definition.each do |k, v|
+      type = Dummy.type(k)
+      if v.respond_to?(:[])
+        if type != v[:type]
+          t.error("expect #{v[:type]} got #{type}")
+        end
+      elsif type != v
+        t.error("expect #{v} got #{type}")
       end
     end
   end
@@ -37,14 +172,69 @@ module TypeStructTest
     end
   end
 
+  def test_arrayof_s_valid?(t)
+    unless A.valid?(:a, [1, 2, 3])
+      t.error("ArrayOf failed with [1,2,3]")
+    end
+  end
+
+  def test_arrayof_union_s_valid?(t)
+    unless A.valid?(:b, [false, true, false])
+      t.error("ArrayOf failed with Union")
+    end
+  end
+
+  def test_union_s_valid?(t)
+    unless A.valid?(:c, false)
+      t.error("Union is invalid with false")
+    end
+  end
+
+  def test_type_struct_s_valid?(t)
+    b = B.new(a: 1, b: false, c: [1, 2, 3], d: [false], e: C.new(a: [true]))
+    unless A.valid?(:d, b)
+      t.error("TypeStruct is invalid with #{b}")
+    end
+  end
+
+  def test_arrayof_type_struct_s_valid?(t)
+    ary_b = [
+      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: false, c: [1, 2, 3], d: [false], e: C.new(a: [true])),
+    ]
+    unless A.valid?(:e, ary_b)
+      t.error("ArrayOf with TypeStruct is invalid with #{ary_b}")
+    end
+  end
+
   def test_initialize(t)
-    expects = {str: "aaa", num: 123, reg: "abc", any: [1, "bbb"]}
-    dummy = Dummy.new(str: "aaa", num: 123, reg: "abc", any: [1, "bbb"])
+    expects = { str: "aaa", num: 123, reg: "abc", ary: [1.1, 1], any: [1, "bbb"] }
+    dummy = Dummy.new(str: "aaa", num: 123, reg: "abc", ary: [1.1, 1], any: [1, "bbb"])
     expects.each do |k, v|
       unless dummy[k] == v
         t.error("expect #{dummy[k]} got #{v}")
       end
     end
+
+    dummy2 = Dummy.new("str" => "aaa", "num" => 123, "reg" => "abc", "ary" => [1.1, 1], "any" => [1, "bbb"])
+    expects.each do |k, v|
+      unless dummy2[k] == v
+        t.error("expect #{dummy2[k]} got #{v}")
+      end
+    end
+  end
+
+  def test_eq(t)
+    dummy1 = Dummy.new(str: "aaa", num: 123, reg: "abc", ary: [1.1, 1], any: [1, "bbb"])
+    dummy2 = Dummy.new(str: "aaa", num: 123, reg: "abc", ary: [1.1, 1], any: [1, "bbb"])
+    dummy3 = Dummy.new(str: "bbb", num: 123, reg: "abc", ary: [1.1, 1], any: [1, "bbb"])
+    unless dummy1 == dummy2
+      t.error("members not equal")
+    end
+    unless dummy1 != dummy3
+      t.error("members equal")
+    end
   end
 
   def test_initialize_not_enough(t)
@@ -62,7 +252,7 @@ module TypeStructTest
   end
 
   def test_to_h(t)
-    expects = {str: "aaa", num: 123, reg: "abcde", any: [1, "bbb"]}
+    expects = { str: "aaa", num: 123, reg: "abcde", any: [1, "bbb"] }
     dummy = Dummy.new(str: "aaa", num: 123, reg: "abcde", any: [1, "bbb"])
     expects.each do |k, v|
       unless dummy[k] == v
@@ -94,7 +284,7 @@ module TypeStructTest
 
   def test_setter(t)
     dummy = Dummy.new(str: "aaa", num: 123, reg: "abc", any: [1, "bbb"])
-    %i(str num reg).each do |k, v|
+    %i(str num reg).each do |k|
       _, err = go { dummy[k] = nil }
       if err == nil
         t.error("expect raise error when invalid value set")
@@ -128,7 +318,7 @@ module TypeStructTest
     str: String,
     reg: /exp/,
     num: Integer,
-    any: Object
+    any: Object,
   ); end
 
   def example_readme

metadata

@@ -1,55 +1,55 @@
 --- !ruby/object:Gem::Specification
 name: type_struct
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.1
 platform: ruby
 authors:
 - ksss
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-24 00:00:00.000000000 Z
+date: 2016-02-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.10'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.10'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
 - !ruby/object:Gem::Dependency
   name: rgot
   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: Imitating static typed struct.
@@ -59,13 +59,17 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .travis.yml
+- ".gitignore"
+- ".travis.yml"
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - lib/type_struct.rb
+- lib/type_struct/arrayof.rb
+- lib/type_struct/ext.rb
+- lib/type_struct/union.rb
+- lib/type_struct/union_test.rb
 - lib/type_struct/version.rb
 - lib/type_struct_test.rb
 - type_struct.gemspec
@@ -79,17 +83,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.14
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Imitating static typed struct.