safestruct 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8c5bfc55add079e7b118ffd749d00c41b1e65b4b
-  data.tar.gz: '0830ae1f8e5416333df86fd3600193fff44ea77e'
+  metadata.gz: aabbb2a559ec2421cc0ac43cdcfb0764c8f01633
+  data.tar.gz: 7c4aa56416aa26f67f06aa09260d0af12f28cf27
 SHA512:
-  metadata.gz: d4fc1b8c74807a0ba06ddc4556addac6924c8ecabb2ba63dec1818e21159f870667b0f951213e5804105bd343bc32ac0159da7fb3592013d2b66ed4560f02b59
-  data.tar.gz: 64cb676719a1bfb17df5cea86dcea78d98a36fb36976548aa32fb95b161eb8b03354c0f66ea1491fc46b153c96a890b60117af55bdd08205271a3569af9504e3
+  metadata.gz: 3b51b663bc4580a435e39d74ea015bc6e407dec307126de09fe818977de527ced949d4d58a2a04f27a10a25074e76fcc17f47139152782804177b28bf0cd5d20
+  data.tar.gz: 5285c818c0b4240f186bbc3f9c4221aa4cdf204ec20f0ac187da6b3b1d2a8a339fe5162802b9fabc8b09c80c2ce77e8a013bb3fb391074229dc978fb886024dd

data/Manifest.txt

@@ -3,4 +3,11 @@ Manifest.txt
 README.md
 Rakefile
 lib/safestruct.rb
+lib/safestruct/safe_array.rb
+lib/safestruct/safe_hash.rb
+lib/safestruct/safe_struct.rb
 lib/safestruct/version.rb
+test/helper.rb
+test/test_array.rb
+test/test_hash.rb
+test/test_struct.rb

data/lib/safestruct.rb

@@ -6,6 +6,63 @@ require 'pp'
 ## our own code
 require 'safestruct/version'    # note: let version always go first
 
+require 'safestruct/safe_array'
+require 'safestruct/safe_hash'
+require 'safestruct/safe_struct'
 
-pp Safe.banner
-pp Safe.root
+
+
+####################################
+## add dummy bool class for mapping and (payable) method signature
+
+class Integer
+  def self.zero() 0; end
+end
+
+class Bool
+  def self.zero() false; end
+end
+
+
+
+#####
+# add "beautiful" convenience helpers
+
+class Mapping
+
+  def self.of( *args )
+     ## e.g. gets passed in [{Address=>Integer}]
+     ##  check for Integer - use Hash.new(0)
+     ##  check for Bool    - use Hash.new(False)
+     if args[0].is_a? Hash
+       arg = args[0].to_a   ## convert to array (for easier access)
+       klass_key   = arg[0][0]
+       klass_value = arg[0][1]
+       klass = SafeHash.build_class( klass_key, klass_value )
+       klass.new
+     else
+       ## todo/fix: throw argument error/exception
+       Hash.new    ## that is, "plain" {} with all "standard" defaults
+     end
+  end
+end
+
+
+class Array
+  ## "typed" safe array "constructor"
+  ## e.g.  Array.of( Address ) or Array.of( Money ) or Array.of( Proposal, size: 2 ) etc.
+  def self.of( klass_value )
+    klass = SafeArray.build_class( klass_value )
+    klass.new  ## todo: add klass.new( **kwargs ) for size: 2 etc.
+  end
+end
+
+
+############################
+# note: HACK redefine built in struct
+#  => warning: already initialized constant Struct
+OldStruct = Struct        ## save old struct class
+Struct    = SafeStruct
+
+
+puts Safe.banner    ## say hello

data/lib/safestruct/safe_array.rb

@@ -0,0 +1,69 @@
+# encoding: utf-8
+
+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
+
+    ## note: keep a class cache
+    cache = @@cache ||= {}
+    klass = cache[ klass_value ]
+    return klass   if klass
+
+    klass = Class.new( SafeArray )
+    klass.class_eval( <<RUBY )
+      def self.klass_value
+        @klass_value ||= #{klass_value}
+      end
+RUBY
+    ## add to cache for later (re)use
+    cache[ klass_value ] = klass
+    klass
+  end
+
+
+  def self.new_zero()  new;  end
+  def self.zero()      @zero ||= new_zero;  end
+
+
+
+  def initialize
+    ## todo/check: if array works if value is a (nested/multi-dimensional) array
+    @ary  = []
+  end
+
+  def []=(index, value)
+    @ary[index] = value
+  end
+
+  def [](index)
+    item = @ary[ index ]
+    if item.nil?
+      ## todo/check:
+      ##    always return (deep) frozen zero object - why? why not?
+      ##     let user change the returned zero object - why? why not?
+      if self.class.klass_value.respond_to?( :new_zero )
+        ## note: use a new unfrozen copy of the zero object
+        ##    changes to the object MUST be possible (new "empty" modifable object expected)
+       item = self.class.klass_value.new_zero
+     else  # assume value semantics e.g. Integer, Bool, etc. zero values gets replaced
+       ## puts "use value semantics"
+       item = self.class.klass_value.zero
+     end
+    end
+    item
+  end
+
+  def push( item )
+    ## todo/fix: check if item.is_a? @type
+    ##   note: Address might be a String too (Address | String)
+    ##     store Address always as String!!! - why? why not?
+    @ary.push( item )
+  end
+
+  def size() @ary.size; end
+  def length() size; end
+end # class SafeArray

data/lib/safestruct/safe_hash.rb

@@ -0,0 +1,77 @@
+# encoding: utf-8
+
+
+class SafeHash
+
+  ## e.g.
+  ##  Mapping.of( Address => Money )
+
+  ##   note: need to create new class!! for every mapping
+  ##     make klass_key class and
+  ##          klass_value class  into class instance variables
+  ##     that can get used by zero
+  ##       self.new returns a Hash.new/SafeHash.new like object
+
+  def self.build_class( klass_key, klass_value )
+    ## note: care for now only about value type / class
+
+    ## note: keep a class cache
+    cache = @@cache ||= {}
+    klass = cache[ klass_value ]
+    return klass   if klass
+
+    klass = Class.new( SafeHash )
+    klass.class_eval( <<RUBY )
+      def self.klass_key
+        @klass_key   ||= #{klass_key}
+      end
+      def self.klass_value
+        @klass_value ||= #{klass_value}
+      end
+RUBY
+    ## add to cache for later (re)use
+    cache[ klass_value ] = klass
+    klass
+  end
+
+
+  def self.new_zero()  new;  end
+  def self.zero()      @zero ||= new_zero;  end
+
+
+  def initialize
+    ## todo/check: if hash works if value is a (nested) hash
+    @h  = {}
+  end
+
+
+  def []=(key, value)
+    @h[key] = value
+  end
+
+  def [](key)
+    item = @h[ key ]
+    if item.nil?
+      ## pp self.class.klass_value
+      ## pp self.class.klass_value.zero
+
+      #####
+      # todo/check:
+      #    add zero to hash on lookup (increases size/length)
+      #    why? why not?
+
+      if self.class.klass_value.respond_to?( :new_zero )
+        ## note: use a dup(licated) unfrozen copy of the zero object
+        ##    changes to the object MUST be possible (new "empty" modifable object expected)
+       item = @h[ key ] = self.class.klass_value.new_zero
+     else  # assume value semantics e.g. Integer, Bool, etc. zero values gets replaced
+       ## puts "use value semantics"
+       item = @h[ key ] = self.class.klass_value.zero
+     end
+    end
+    item
+  end
+
+  def size() @h.size; end
+  def length() size; end
+end # class SafeHash

data/lib/safestruct/safe_struct.rb

@@ -0,0 +1,79 @@
+# encoding: utf-8
+
+class SafeStruct
+
+def self.build_class( **attributes )
+  klass = Class.new( SafeStruct ) do
+    define_method( :initialize ) do |*args|
+      attributes.keys.zip( args ).each do |key, arg|
+        instance_variable_set( "@#{key}", arg )
+      end
+      self  ## note: return reference to self for chaining method calls
+    end
+
+    attributes.each do |key,value|
+      define_method( key ) do
+        instance_variable_get( "@#{key}" )
+      end
+      if value == false  ## note: for Bool add getter with question mark (e.g. voted? etc.)
+        define_method( "#{key}?" ) do
+          instance_variable_get( "@#{key}" )
+        end
+      end
+      define_method( "#{key}=" ) do |arg|
+        instance_variable_set( "@#{key}", arg )
+      end
+    end
+
+    define_method( :== ) do |other|
+       return false unless other.is_a?( klass )
+        attributes.keys.all? do |key|
+          __send__( key ) == other.__send__( key )
+        end
+    end
+    alias_method :eql?, :==
+  end
+
+  ## add self.new too - note: call/forward to "old" orginal self.new of Event (base) class
+  klass.define_singleton_method( :new ) do |*args|
+    if args.size != attributes.size
+      ## check for required args/params - all MUST be passed in!!!
+      raise ArgumentError.new( "[SafeStruct] wrong number of arguments for #{name}.new - #{args.size} for #{attributes.size}" )
+    end
+    old_new( *args )
+  end
+
+  klass.define_singleton_method( :new_zero ) do
+    ## note: if attribute value is a composite
+    ##     use new_zero to create a new instance!!!
+    ##     do NOT use the passed in reference!!!!
+    values = attributes.values.map do |value|
+      if value.is_a?(SafeStruct) ||
+         value.is_a?(SafeArray)  ||
+         value.is_a?(SafeHash)
+         value.class.new_zero
+      else
+        ## assume "value" object / semantics (e.g. 0, false, '0x0000' etc.) and pass through
+        value
+      end
+    end
+    old_new( *values )
+  end
+
+  klass
+end # method build_class
+
+class << self
+  alias_method :old_new, :new       # note: store "old" orginal version of new
+  alias_method :new,     :build_class    # replace original version with create
+end
+
+def self.zero
+  ## note: freeze return new zero (for "singelton" & "immutable" zero instance)
+  ##  todo/fix:
+  ##   in build_class add freeze for composite/reference objects
+  ##     that is, arrays, hash mappings, structs etc.
+  ##   freeze only works for now for "value" objects e.g. integer, bool, etc.
+  @zero ||= new_zero.freeze
+end
+end # class SafeStruct

data/lib/safestruct/version.rb

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

data/test/helper.rb

@@ -0,0 +1,8 @@
+## minitest setup
+
+require 'minitest/autorun'
+
+
+## our own code
+
+require 'safestruct'

data/test/test_array.rb

@@ -0,0 +1,52 @@
+# encoding: utf-8
+
+###
+#  to run use
+#     ruby -I ./lib -I ./test test/test_array.rb
+
+
+require 'helper'
+
+
+class TestArray < MiniTest::Test
+
+  Array_Integer = SafeArray.build_class( Integer )
+  Array_Bool    = SafeArray.build_class( Bool )
+
+def test_integer
+  pp Array_Integer
+  pp ary = Array_Integer.new
+
+  assert_equal Integer, Array_Integer.klass_value
+  assert_equal 0, ary[0]
+  assert_equal 0, ary[1]
+
+  ary[0] = 101
+  ary[1] = 102
+  assert_equal 101,  ary[0]
+  assert_equal 102,  ary[1]
+
+  ## check Array.of  (uses cached classes)
+  assert_equal Array_Integer, Array.of( Integer ).class
+end
+
+
+def test_bool
+  pp Array_Bool
+  pp ary = Array_Bool.new
+
+  assert_equal Bool, Array_Bool.klass_value
+  assert_equal false,  ary[0]
+  assert_equal false,  ary[1]
+
+  ary[0] = true
+  ary[1] = true
+  assert_equal true,  ary[0]
+  assert_equal true,  ary[1]
+
+  ## check Array.of  (uses cached classes)
+  assert_equal Array_Bool, Array.of( Bool ).class
+end
+
+
+end # class TestArray

data/test/test_hash.rb

@@ -0,0 +1,77 @@
+# encoding: utf-8
+
+###
+#  to run use
+#     ruby -I ./lib -I ./test test/test_hash.rb
+
+
+require 'helper'
+
+
+class TestHash < MiniTest::Test
+
+  ## sig: [Integer, Bool, Integer, Address]
+  Voter = SafeStruct.new( weight: 0, voted: false, vote: 0, delegate: '0x0000' )
+
+  Hash_X_Integer = SafeHash.build_class( String, Integer )
+  Hash_X_Bool    = SafeHash.build_class( String, Bool )
+  Hash_X_Voter   = SafeHash.build_class( String, Voter )
+
+def test_integer
+  pp Hash_X_Integer
+  pp h = Hash_X_Integer.new
+
+  assert_equal Integer, Hash_X_Integer.klass_value
+  assert_equal 0,  h['0x1111']
+  assert_equal 0,  h['0x2222']
+
+  h['0x1111'] = 101
+  h['0x2222'] = 102
+  assert_equal 101,  h['0x1111']
+  assert_equal 102,  h['0x2222']
+
+  ## check Mapping.of  (uses cached classes)
+  assert_equal Hash_X_Integer, Mapping.of( String => Integer ).class
+end
+
+
+def test_bool
+  pp Hash_X_Bool
+  pp h = Hash_X_Bool.new
+
+  assert_equal Bool, Hash_X_Bool.klass_value
+  assert_equal false,  h['0x1111']
+  assert_equal false,  h['0x2222']
+
+  h['0x1111'] = true
+  h['0x2222'] = true
+  assert_equal true,  h['0x1111']
+  assert_equal true,  h['0x2222']
+
+  ## check Mapping.of  (uses cached classes)
+  assert_equal Hash_X_Bool, Mapping.of( String => Bool ).class
+end
+
+
+def test_voter
+  pp Hash_X_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']
+
+  h['0x1111'].voted = true
+  h['0x2222'].voted = true
+  assert_equal true,  h['0x1111'].voted?
+  assert_equal true,  h['0x2222'].voted?
+
+  pp h['0x1111']
+  pp h['0x2222']
+
+  ## check Mapping.of  (uses cached classes)
+  assert_equal Hash_X_Voter, Mapping.of( String => Voter ).class
+end
+
+
+end # class TestHash

data/test/test_struct.rb

@@ -0,0 +1,77 @@
+# encoding: utf-8
+
+###
+#  to run use
+#     ruby -I ./lib -I ./test test/test_struct.rb
+
+
+require 'helper'
+
+
+class TestStruct < MiniTest::Test
+
+## sig: [Integer, Bool, Integer, Address]
+Voter = SafeStruct.new( weight: 0, voted: false, vote: 0, delegate: '0x0000' )
+
+## sig: [Address, Integer, Integer, Money]
+Bet   = SafeStruct.new( user: '0x0000', block: 0, cap: 0, amount: 0 )
+
+
+def test_voter
+  assert_equal 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 )
+
+  voter.delegate = '0x1111'
+  pp voter
+
+  assert       Voter.zero != voter
+
+  voter2 = Voter.new( 0, false, 0, '0x0000' )
+  assert_equal Voter.zero, voter2
+  assert_equal false,      voter2.frozen?
+end
+
+def test_bet
+  pp Bet
+  bet = Bet.new_zero
+  pp bet
+
+  assert_equal Bet.zero, bet
+
+  bet.cap    = 20_000
+  bet.amount = 100
+
+  assert_equal false,  bet.frozen?
+  assert_equal 20_000, bet.cap
+  assert_equal 100,    bet.amount
+  assert       Bet.zero != bet
+
+  pp bet
+
+  pp Bet.zero
+  pp Bet.zero
+
+  assert_equal 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?
+end
+
+end # class TestStruct

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: safestruct
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Gerald Bauer
@@ -53,7 +53,14 @@ files:
 - README.md
 - Rakefile
 - lib/safestruct.rb
+- lib/safestruct/safe_array.rb
+- lib/safestruct/safe_hash.rb
+- lib/safestruct/safe_struct.rb
 - lib/safestruct/version.rb
+- test/helper.rb
+- test/test_array.rb
+- test/test_hash.rb
+- test/test_struct.rb
 homepage: https://github.com/s6ruby/safestruct
 licenses:
 - Public Domain