safestruct 1.1.0 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 566fae2d8f89cb24afd577666383dd7944811152
-  data.tar.gz: 6b72e279ae328f1fdac760691ad57d92e991ab21
+  metadata.gz: e972352c0dbb2c3684a3de9385f33efb706a7cca
+  data.tar.gz: 9fb3502f891afab88650aa288bfc39d84ac5f236
 SHA512:
-  metadata.gz: f756d180e311fef89fc4325bcb873bcaaaa02e73cba6ce8d34081352ff46a99307e76470dadec5ede89ab7ea7869d8d1f8a70260860c452f4a5a8783165bd5c2
-  data.tar.gz: bf9226fd8c07a2f63ee309e5b6ebbd7da7551bcaf350691bf715c9ebb8c7e48250b9b88765ad1dbf8d7c09ee07f46b6e3d39e63684276e759529187e7cbc15e4
+  metadata.gz: de271ceb36e33cf627911d60e69c5120e2e8cde48ac84d1ef258571a98e36757695345b4e3ac58a77e0086e76f8ad393a13a6567f8b738fe380c41a47c63bb94
+  data.tar.gz: 4863ee4959e548d6686ca1020b8be99897a0945ebb3eef35becc7bc77d028ba1858d0d2c9b4e6f9b9066baedf636c6c3b2911aaa8a49d1e1b33bda9c2b6420e8

data/lib/safestruct.rb

@@ -67,8 +67,8 @@ class Array
     ## note: for nested Hash.of or Array.of a ("prototype") object
     ##        gets passed in (NOT class) - auto-convert to use class
     klass_value = klass_or_proto_value.is_a?( Class ) ? klass_or_proto_value : klass_or_proto_value.class
-    klass = Safe::SafeArray.build_class( klass_value )
-    klass.new( size )
+    klass = Safe::SafeArray.build_class( klass_value, size )
+    klass.new
   end
 end
 

data/lib/safestruct/safe_array.rb

@@ -5,14 +5,15 @@ module Safe
 class SafeArray
 
   ## e.g.
-  ##  Array.of( Address ), Array.of( Integer), etc.
-
-  def self.build_class( klass_value )
-    ## note: care for now only about value type / class
+  ##  Array.of( Address ), Array.of( Integer),
+  ##  Array.of( Integer, 3 ) or Array.of( Integer, 3*3 ) etc.
 
+  def self.build_class( klass_value, size=0 )
     ## note: keep a class cache
-    cache = @@cache ||= {}
-    klass = cache[ klass_value ]
+    ##  note: klasses may have different init sizes (default 0)
+    cache           = @@cache ||= {}
+    cache_all_sizes = cache[ klass_value ] ||= {}
+    klass           = cache_all_sizes[ size ]
 
     if klass.nil?
 
@@ -21,9 +22,12 @@ class SafeArray
         def self.klass_value
           @klass_value ||= #{klass_value}
         end
+        def self.klass_size
+          @klass_size  ||= #{size}
+        end
 RUBY
       ## add to cache for later (re)use
-      cache[ klass_value ] = klass
+      cache[ klass_value ][ size ] = klass
     end
     klass
   end
@@ -33,9 +37,7 @@ RUBY
   def self.zero()      @zero ||= new_zero.freeze;  end
 
 
-
-  def initialize( size=0 )
-    ## todo/check: if array works if value is a (nested/multi-dimensional) array
+  def initialize( size=self.class.klass_size )
     @ary  = []
     self.size = size   if size > 0  ## auto-init with zeros
     self   # return reference to self
@@ -102,8 +104,17 @@ RUBY
     @ary.size
   end
 
+  def clear
+    ## note: reset ary to zero  (NOT empty e.g. [])
+    ##         differes for "fixed" size arrays
+    @ary = []
+    self.size = self.class.klass_size   if self.class.klass_size > 0  ## auto-init with zeros
+    self  # return reference to self
+  end
+
+
 extend Forwardable
-def_delegators :@ary, :size, :length, :clear,
+def_delegators :@ary, :size, :length,
                       :each, :each_with_index
 
 

data/lib/safestruct/version.rb

@@ -5,7 +5,7 @@ module Safe
 
   MAJOR = 1
   MINOR = 1
-  PATCH = 0
+  PATCH = 1
   VERSION = [MAJOR,MINOR,PATCH].join('.')
 
   def self.version

data/test/test_array.rb

@@ -18,6 +18,10 @@ class TestArray < MiniTest::Test
   ## multi-dimensional / nested  array
   Array_Array_Integer = SafeArray.build_class( Array_Integer )
 
+  ## "fixed" size
+  Array_3_Integer         = SafeArray.build_class( Integer, 3 )
+  Array_Array_3x3_Integer = SafeArray.build_class( Array_3_Integer, 3 )
+
 
 def test_push_and_clear
   ary = Array_Integer.new
@@ -40,6 +44,7 @@ def test_integer
   pp ary = Array_Integer.new(2)
 
   assert_equal Integer, Array_Integer.klass_value
+  assert_equal 0,       Array_Integer.klass_size
   assert_equal 0, ary[0]
   assert_equal 0, ary[1]
 
@@ -56,14 +61,15 @@ def test_integer
   ary.each_with_index { |item,i| puts "[#{i}] #{item}"}
 
   ary.size = 3
-  assert_equal 3, ary.size
-  assert_equal 0, ary[2]
-  assert       Array_Integer.zero != ary
+  assert_equal 3,     ary.size
+  assert_equal 0,     ary[2]
+  assert_equal false, Array_Integer.zero == ary
 
   pp Array_Integer.zero
-  assert_equal true,               Array_Integer.zero.frozen?
-  assert_equal Array_Integer.zero, Array_Integer.zero
-  assert_equal Array_Integer.zero, Array_Integer.new
+  assert_equal true,  Array_Integer.zero.frozen?
+  assert_equal true,  Array_Integer.zero == Array_Integer.zero
+  assert_equal true,  Array_Integer.zero == Array_Integer.new
+  assert_equal true,  Array_Integer.zero == Array_Integer.new_zero
 
   ## check Array.of  (uses cached classes)
   assert_equal Array_Integer, Array.of( Integer ).class
@@ -75,6 +81,7 @@ def test_bool
   pp ary = Array_Bool.new(2)
 
   assert_equal Bool, Array_Bool.klass_value
+  assert_equal 0,    Array_Bool.klass_size
   assert_equal false,  ary[0]
   assert_equal false,  ary[1]
 
@@ -96,10 +103,6 @@ def test_array_of
 end
 
 def test_multi  # nested (multi-dimensional) array
-  ## todo/fix: try with size: 3  e.g. 3x3
-  ##   make it work with size too!!!!!
-  ##    remember size if passed in in c'tor!!!!!!
-
    multi = Array_Array_Integer.new
    multi.push( Array_Integer.new )
    multi[0].push( 100 )
@@ -138,4 +141,87 @@ def test_multi  # nested (multi-dimensional) array
    assert_equal 0, multi.size
 end
 
+def test_3x3  # nested (multi-dimensional) array
+   board = Array_Array_3x3_Integer.new
+   pp board
+
+   assert_equal Integer, Array_3_Integer.klass_value
+   assert_equal 3,       Array_3_Integer.klass_size
+
+   assert_equal Array_3_Integer, Array_Array_3x3_Integer.klass_value
+   assert_equal 3,               Array_Array_3x3_Integer.klass_size
+
+   assert_equal 0, board[0][0]
+   assert_equal 0, board[0][1]
+   assert_equal 0, board[0][2]
+   assert_equal 0, board[1][0]
+   assert_equal 0, board[1][1]
+   assert_equal 0, board[1][2]
+   assert_equal 0, board[2][0]
+   assert_equal 0, board[2][1]
+   assert_equal 0, board[2][2]
+
+   board[0][0] = 1
+   board[0][1] = 2
+   board[0][2] = 1
+   board[1][0] = 2
+   pp board
+
+   assert_equal 1, board[0][0]
+   assert_equal 2, board[0][1]
+   assert_equal 1, board[0][2]
+   assert_equal 2, board[1][0]
+
+   board[0].clear
+   pp board[0]
+   assert_equal 3, board[0].size
+   assert_equal 0, board[0][0]
+   assert_equal 0, board[0][1]
+   assert_equal 0, board[0][2]
+
+   board.clear
+   assert_equal 3, board.size
+   assert_equal 3, board[0].size
+   assert_equal 3, board[1].size
+   assert_equal 3, board[2].size
+
+   assert_equal 0, board[0][0]
+   assert_equal 0, board[0][1]
+   assert_equal 0, board[0][2]
+   assert_equal 0, board[1][0]
+   assert_equal 0, board[1][1]
+   assert_equal 0, board[1][2]
+   assert_equal 0, board[2][0]
+   assert_equal 0, board[2][1]
+   assert_equal 0, board[2][2]
+
+   ##############################################
+   ## try Array.of convenience helper
+
+   board = Array.of( Array.of( Integer, 3 ), 3 )
+   pp board
+
+   assert_equal 0, board[0][0]
+   assert_equal 0, board[0][1]
+   assert_equal 0, board[0][2]
+   assert_equal 0, board[1][0]
+   assert_equal 0, board[1][1]
+   assert_equal 0, board[1][2]
+   assert_equal 0, board[2][0]
+   assert_equal 0, board[2][1]
+   assert_equal 0, board[2][2]
+
+   board[0][0] = 1
+   board[0][1] = 2
+   board[0][2] = 1
+   board[1][0] = 2
+   pp board
+
+   assert_equal 1, board[0][0]
+   assert_equal 2, board[0][1]
+   assert_equal 1, board[0][2]
+   assert_equal 2, board[1][0]
+end
+
+
 end # class TestArray

data/test/test_hash.rb

@@ -33,8 +33,9 @@ def test_integer
   assert_equal 0, h.instance_variable_get('@h').size
   assert_equal 0, h.instance_variable_get('@h').length
 
-  assert_equal Hash_X_Integer.zero, h
-  assert_equal Hash_X_Integer.zero, Hash_X_Integer.new
+  assert_equal true, Hash_X_Integer.zero == h
+  assert_equal true, Hash_X_Integer.zero == Hash_X_Integer.new
+  assert_equal true, Hash_X_Integer.zero == Hash_X_Integer.new_zero
 
   pp Hash_X_Integer.zero
   assert_equal true,   Hash_X_Integer.zero.frozen?
@@ -79,8 +80,8 @@ def test_voter
   pp h = Hash_X_Voter.new
 
   assert_equal Voter, Hash_X_Voter.klass_value
-  assert_equal Voter.zero, h['0x1111']
-  assert_equal Voter.zero, h['0x2222']
+  assert_equal true, Voter.zero == h['0x1111']
+  assert_equal true, Voter.zero == h['0x2222']
 
   h['0x1111'].voted = true
   h['0x2222'].voted = true

data/test/test_struct.rb

@@ -19,37 +19,85 @@ Voter = SafeStruct.new( weight: 0, voted: false, vote: 0, delegate: '0x0000' )
 Bet   = SafeStruct.new( user: '0x0000', block: 0, cap: 0, amount: 0 )
 
 
+
+### test with "real" enum
+class Enum
+  def initialize( key, value )
+    @key   = key
+    @value = value
+  end
+end
+
+class Winner < Enum
+  NONE       = new(:none, 0 )
+  DRAW       = new(:draw, 1 )
+  HOST       = new(:host, 2 )
+  CHALLENGER = new(:challenger, 3)
+
+  def self.none()       NONE;       end
+  def self.draw()       DRAW;       end
+  def self.host()       HOST;       end
+  def self.challenger() CHALLENGER; end
+
+  def none?()       self == NONE; end
+  def draw?()       self == DRAW; end
+  def host?()       self == HOST; end
+  def challenger?() self == CHALLENGER; end
+end
+
+Board = Array_9_Integer = SafeArray.build_class( Integer, 3*3 )
+
+## sig: [Address, Address, Address, Winner(Enum), Board(Array9)]
+Game = SafeStruct.new( host:       '0x0000',
+                       challenger: '0x0000',
+                       turn:       '0x0000',   ## address of host/ challenger
+                       winner:     Winner.none,
+                       board:      Board.zero
+                     )
+
 def test_voter
-  assert_equal Voter.zero, Voter.zero
+  assert_equal true,       Voter.zero.frozen?
+  assert_equal true,       Voter.zero == Voter.zero
+
   assert_equal '0x0000',   Voter.zero.delegate
   assert_equal false,      Voter.zero.voted?
   assert_equal 0,          Voter.zero.weight
   assert_equal 0,          Voter.zero.vote
-  assert_equal true,       Voter.zero.frozen?
 
   voter = Voter.new_zero
 
   assert_equal false,      voter.frozen?
-  assert_equal Voter.zero, voter
-  assert       Voter.zero == voter
-  assert       Voter.zero.eql?( voter )
+  assert_equal true,       Voter.zero == voter
+  assert_equal true,       Voter.zero.eql?( voter )
+  assert_equal true,       Voter.zero == Voter.new
+  assert_equal true,       Voter.zero == Voter.new_zero
+
 
   voter.delegate = '0x1111'
   pp voter
 
-  assert       Voter.zero != voter
+  assert_equal false,     Voter.zero == voter
 
-  voter2 = Voter.new( 0, false, 0, '0x0000' )
-  assert_equal Voter.zero, voter2
-  assert_equal false,      voter2.frozen?
+  ##############
+  # try a new voter
+  voter = Voter.new( 0, false, 0, '0x0000' )
+  assert_equal true,      Voter.zero == voter
+  assert_equal false,     voter.frozen?
 end
 
+
 def test_bet
   pp Bet
+  assert_equal true, Bet.zero.frozen?
+  assert_equal true, Bet.zero == Bet.zero
+
+
   bet = Bet.new_zero
   pp bet
 
-  assert_equal Bet.zero, bet
+  assert_equal true,   Bet.zero == bet
+  assert_equal true,   Bet.zero == Bet.new
+  assert_equal true,   Bet.zero == Bet.new_zero
 
   bet.cap    = 20_000
   bet.amount = 100
@@ -57,23 +105,69 @@ def test_bet
   assert_equal false,  bet.frozen?
   assert_equal 20_000, bet.cap
   assert_equal 100,    bet.amount
-  assert       Bet.zero != bet
+  assert_equal false,  Bet.zero == bet
 
   pp bet
 
   pp Bet.zero
   pp Bet.zero
 
-  assert_equal Bet.zero,   Bet.zero
+  assert_equal true,       Bet.zero == Bet.zero
   assert_equal '0x0000',   Bet.zero.user
   assert_equal 0,          Bet.zero.block
   assert_equal 0,          Bet.zero.cap
   assert_equal 0,          Bet.zero.amount
   assert_equal true,       Bet.zero.frozen?
 
-  bet2 = Bet.new( '0x0000', 0, 0, 0 )
-  assert_equal Bet.zero, bet2
-  assert_equal false,    bet2.frozen?
+  #############################
+  # try a new bet
+  bet = Bet.new( '0x0000', 0, 0, 0 )
+  assert_equal true,     Bet.zero == bet
+  assert_equal false,    bet.frozen?
+end
+
+def test_game
+  pp Game
+  assert_equal true, Game.zero.frozen?
+  assert_equal true, Game.zero == Game.zero
+
+  game = Game.new_zero
+  pp game
+
+  assert_equal true,        Game.zero == game
+  assert_equal true,        Game.zero == Game.new
+  assert_equal true,        Game.zero == Game.new_zero
+  assert_equal false,       game.frozen?
+
+  assert_equal '0x0000',    game.host
+  assert_equal '0x0000',    game.challenger
+  assert_equal '0x0000',    game.turn
+  assert_equal Winner.none, game.winner
+  assert_equal true,        game.winner.none?
+  assert_equal Board.zero,  game.board
+  assert_equal 9,           game.board.size
+  assert_equal 0,           game.board[0]
+  assert_equal 0,           game.board[1]
+  assert_equal 0,           game.board[2]
+  assert_equal 0,           game.board[3]
+  assert_equal 0,           game.board[4]
+  assert_equal 0,           game.board[5]
+  assert_equal 0,           game.board[6]
+  assert_equal 0,           game.board[7]
+  assert_equal 0,           game.board[8]
+
+
+  game.winner = Winner.host
+  assert_equal false, Game.zero == game
+  pp game
+
+  #####
+  # try a new game
+  game = Game.new
+  game.board[0] = 1
+  assert_equal false, Game.zero == game
+  pp game
 end
 
+
 end # class TestStruct

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: safestruct
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.1.1
 platform: ruby
 authors:
 - Gerald Bauer