rubidity 0.9.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e4839b48c7fbebac1bbc15722701b60bc26494cba550ddea5385c8c2d9e5b76d
+  data.tar.gz: 5e8ca8ed8c4865aa857f86554574af2b58297038551587d004ef2104f523dfc0
+SHA512:
+  metadata.gz: b3e6ba134973d9e02957a4c8232e102dba2f47bba5da411deda393b24273b066cdd079ec15c2c5f874de84557b623f2117f33bdfb4fbd2692674b7658ccf0f97
+  data.tar.gz: 2b186987456561a83229bc20a1e50316ce218c1207d17d8bc1a5267c3fcfb41d7ef97315a06fdaad82e630858d1d2ee5122f389c4ab16b275b964ea0d198a3c9

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+### 0.9.0 / 2023-11-16
+
+* Everything is new. First release

data/Manifest.txt

@@ -0,0 +1,9 @@
+CHANGELOG.md
+Manifest.txt
+README.md
+Rakefile
+lib/rubidity.rb
+lib/rubidity/builder.rb
+lib/rubidity/codegen.rb
+lib/rubidity/proc.rb
+lib/rubidity/version.rb

data/README.md

@@ -0,0 +1,603 @@
+# Rubidity "Classic / O.G." Contract Builder
+
+**DISCLAIMER:   the rubidity gem version is different 
+from the rubidity built into the facet vm / app and i (Gerald Bauer) 
+am NOT affiliated with facet computing inc. (middlemarch et al) or paid to work on the rubidity gem.**
+
+
+rubidity gem - rubidity "classic / o.g." contract builder; trying the impossible and square the circle, that is, a rubidity "classic / o.g." dsl builder generating rubysol "more ruby-ish" contract classes. 
+
+
+* home  :: [github.com/s6ruby/rubidity](https://github.com/s6ruby/rubidity)
+* bugs  :: [github.com/s6ruby/rubidity/issues](https://github.com/s6ruby/rubidity/issues)
+* gem   :: [rubygems.org/gems/rubidity](https://rubygems.org/gems/rubidity)
+* rdoc  :: [rubydoc.info/gems/rubidity](http://rubydoc.info/gems/rubidity)
+
+
+
+## What's Solidity?! What's Rubidity?! What's Rubysol?!
+
+See [**Solidity - Contract Application Binary Interface (ABI) Specification** »](https://docs.soliditylang.org/en/latest/abi-spec.html)
+
+See [**Rubidity - Ruby for Layer 1 (L1) Contracts / Protocols with "Off-Chain" Indexer**  »](https://github.com/s6ruby/rubidity)
+
+See [**Rubysol - Ruby for Layer 1 (L1) Contracts / Protocols with "Off-Chain" Indexer**  »](https://github.com/s6ruby/rubidity/tree/master/rubysol)
+
+
+
+
+
+## Usage
+
+[Contract Sample №1 - HelloWorld](#contract-sample-1---helloworld) •
+[Contract Sample №2 - PublicMintERC20](#contract-sample-2---publicminterc20) •
+[Contract Sample №3 - SupplyChain](#contract-sample-3---supplychain)
+
+
+### Contract Sample №1 - HelloWorld 
+
+Let's try the HelloWorld contract.
+
+[HelloWorld](contracts/HelloWorld.rb) - main contract in rubidity classic / o.g. style
+
+``` ruby
+pragma :rubidity, "1.0.0"
+
+contract :HelloWorld do
+  function :getHelloWorld, {}, :public, :pure, returns: :string do
+    return "Hello, world!"
+  end
+end
+```
+
+Now let's square the circle and try the impossible.
+Let's run the HelloWorld contract.
+
+
+``` ruby
+require 'rubidity'
+
+# load (parse) and generate contract classes
+Contract.load( 'HelloWorld' )
+
+
+#  try out contract classes
+pp HelloWorld
+pp HelloWorld.name
+
+contract = HelloWorld.new
+pp contract
+
+pp contract.getHelloWorld
+#=> "Hello, world!"
+```
+
+
+
+
+### Contract Sample №2 - PublicMintERC20 
+
+Let's try the PublicMintERC20 contract.
+
+
+[ERC20](contracts/ERC20.rb) - base contract in rubidity classic / o.g. style
+
+``` ruby
+pragma :rubidity, "1.0.0"
+
+contract :ERC20, abstract: true do
+  event :Transfer, { from: :address, to: :address, amount: :uint256 }
+  event :Approval, { owner: :address, spender: :address, amount: :uint256 }
+
+  string :public, :name
+  string :public, :symbol
+  uint8 :public, :decimals
+  
+  uint256 :public, :totalSupply
+
+  mapping ({ address: :uint256 }), :public, :balanceOf
+  mapping ({ address: mapping(address: :uint256) }), :public, :allowance
+  
+  
+  constructor(name: :string, symbol: :string, decimals: :uint8) do 
+    s.name = name
+    s.symbol = symbol
+    s.decimals = decimals
+  end
+
+
+  function :approve, { spender: :address, amount: :uint256 }, :public, :virtual, returns: :bool do
+    s.allowance[msg.sender][spender] = amount
+    
+    emit :Approval, owner: msg.sender, spender: spender, amount: amount
+    
+    return true
+  end
+  
+  function :transfer, { to: :address, amount: :uint256 }, :public, :virtual, returns: :bool do
+    require(s.balanceOf[msg.sender] >= amount, 'Insufficient balance')
+    
+    s.balanceOf[msg.sender] -= amount
+    s.balanceOf[to] += amount
+
+    emit :Transfer, from: msg.sender, to: to, amount: amount
+    
+    return true
+  end
+  
+  function :transferFrom, {
+    from: :address,
+    to: :address,
+    amount: :uint256
+  }, :public, :virtual, returns: :bool do
+    allowed = s.allowance[from][msg.sender]
+    
+    require(s.balanceOf[from] >= amount, 'Insufficient balance')
+    require(allowed >= amount, 'Insufficient allowance')
+    
+    s.allowance[from][msg.sender] = allowed - amount
+    
+    s.balanceOf[from] -= amount
+    s.balanceOf[to] += amount
+    
+    emit :Transfer, from: from, to: to, amount: amount
+    
+    return true
+  end
+  
+  function :_mint, { to: :address, amount: :uint256 }, :internal, :virtual do
+    s.totalSupply += amount
+    s.balanceOf[to] += amount
+    
+    emit :Transfer, from: address(0), to: to, amount: amount
+  end
+  
+  function :_burn, { from: :address, amount: :uint256 }, :internal, :virtual do
+    s.balanceOf[from] -= amount
+    s.totalSupply -= amount
+    
+    emit :Transfer, from: from, to: address(0), amount: amount
+  end
+end
+```
+
+
+[PublicMintERC20](contracts/PublicMintERC20.rb) - main contract in rubidity classic / o.g. style
+
+``` ruby
+pragma :rubidity, "1.0.0"
+
+import './ERC20'
+
+contract :PublicMintERC20, is: :ERC20 do
+  uint256 :public, :maxSupply
+  uint256 :public, :perMintLimit
+  
+  constructor(
+    name: :string,
+    symbol: :string,
+    maxSupply: :uint256,
+    perMintLimit: :uint256,
+    decimals: :uint8
+  ) do 
+    super( name: name, symbol: symbol, decimals: decimals )
+    s.maxSupply = maxSupply
+    s.perMintLimit = perMintLimit
+  end
+  
+  function :mint, { amount: :uint256 }, :public do
+    require(amount > 0, 'Amount must be positive')
+    require(amount <= s.perMintLimit, 'Exceeded mint limit')
+    
+    require(s.totalSupply + amount <= s.maxSupply, 'Exceeded max supply')
+    
+    _mint(to: msg.sender, amount: amount)
+  end
+  
+  function :airdrop, { to: :address, amount: :uint256 }, :public do
+    require(amount > 0, 'Amount must be positive')
+    require(amount <= s.perMintLimit, 'Exceeded mint limit')
+    
+    require(s.totalSupply + amount <= s.maxSupply, 'Exceeded max supply')
+    
+    _mint(to: to, amount: amount)
+  end
+end
+```
+
+
+
+Now let's square the circle and try the impossible.
+Let's run the PublicMintERC20 contract.
+
+
+``` ruby
+require 'rubidity'
+
+# load (parse) and generate contract classes
+Contract.load( 'PublicMintERC20' )
+
+
+# try out contract classes
+pp ERC20
+pp PublicMintERC20
+
+pp ERC20.name
+pp PublicMintERC20.name
+
+pp ERC20::Transfer   # "scoped" (typed) Event class
+pp ERC20::Approval   # "scoped" (typed) Event class
+pp ERC20::Transfer.name 
+pp ERC20::Approval.name
+
+pp ERC20::Transfer.new( from: address(0), to: address(0), amount: 0)
+pp ERC20::Approval.new( owner: address(0), spender: address(0), amount: 0)
+
+
+contract = ERC20.new
+pp contract
+contract.constructor( name: 'My Fun Token',
+                      symbol: 'FUN',
+                      decimals: 18 )
+
+pp contract
+
+
+contract = PublicMintERC20.new
+pp contract
+contract.constructor( name: 'My Fun Token',
+                      symbol: 'FUN',
+                      maxSupply: 21000000,
+                      perMintLimit: 10000,
+                      decimals: 18 )
+pp contract
+pp contract.serialize
+
+
+# test drive with alice, bob & charlie address
+
+alice   = '0x'+'a'*40 # e.g. '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'
+bob     = '0x'+'b'*40 # e.g. '0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb'
+charlie = '0x'+'c'*40 # e.g. '0xcccccccccccccccccccccccccccccccccccccccc'
+
+pp alice
+pp bob
+pp charlie
+
+
+# try mint  
+Runtime.msg.sender = alice
+
+contract.mint( 1000 )   
+contract.mint( 100 )   
+
+pp contract.serialize
+
+
+
+Runtime.msg.sender = bob
+
+contract.mint( 500 )   
+contract.mint( 10 )   
+
+pp contract.serialize
+
+
+pp contract.totalSupply
+pp contract.balanceOf( alice )
+pp contract.balanceOf( bob )
+pp contract.serialize
+
+
+
+# try transfer
+Runtime.msg.sender = alice
+
+contract.transfer( to: bob, amount: 111 )
+contract.transfer( to: charlie, amount: 11 )
+
+
+Runtime.msg.sender = bob
+
+contract.transfer( to: alice, amount: 11 )
+contract.transfer( to: charlie, amount: 111 )
+
+
+
+pp contract.totalSupply
+pp contract.balanceOf( alice )
+pp contract.balanceOf( bob )
+pp contract.balanceOf( charlie )
+
+pp contract.serialize
+#=> {:name=>"My Fun Token",
+#    :symbol=>"FUN",
+#    :decimals=>18,
+#    :totalSupply=>1610,
+#    :balanceOf=>
+#     {"0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"=>989,
+#      "0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"=>499,
+#      "0xcccccccccccccccccccccccccccccccccccccccc"=>122},
+#    :allowance=>{},
+#    :maxSupply=>21000000,
+#    :perMintLimit=>10000}
+
+# and so on.
+```
+
+that's it.
+
+
+
+### Contract Sample №3 - SupplyChain 
+
+Let's try the SupplyChain contract.
+
+[SupplyChain](contracts/SupplyChain.rb) - main contract in rubidity classic / o.g. style
+
+
+``` ruby
+pragma :rubidity, "1.0.0"
+
+contract :SupplyChain do
+
+  event :Transfer, { productId: :uint32 }
+
+  struct :Product, { modelNumber:  :string,
+                     partNumber:   :string,
+                     serialNumber: :string,
+                     productOwner: :address,
+                     cost:         :uint32,
+                     mfgTimestamp: :timestamp }
+
+  struct :Participant, { userName: :string,
+                         password: :string,
+                         participantType: :string,
+                         participantAddress: :address }
+
+  struct :Registration, { productId:    :uint32,  
+                          ownerId:      :uint32, 
+                          productOwner: :address,
+                          trxTimestamp: :timestamp }                    
+ 
+  uint32 :public, :p_id    # (last) product id 
+  uint32 :public, :u_id    # (last) participant id
+  uint32 :public, :r_id    # (last) registration id
+
+  mapping ({ uint32: :Product }),      :public, :products
+  mapping ({ uint32: :Participant }),  :public, :participants
+  mapping ({ uint32: :Registration }), :public, :registrations
+
+  # movement track for a product
+  mapping ({ uint32: array( :uint32 ) }), :public, :productTrack  
+
+
+  function :createParticipant, { name: :string, 
+                                 pass: :string, 
+                                 addr: :address, 
+                                 type: :string }, :public, returns: :uint32 do
+      userId = s.u_id += 1
+      s.participants[ userId ].userName = name
+      s.participants[ userId ].password = pass
+      s.participants[ userId ].participantAddress = addr
+      s.participants[ userId ].participantType = type
+      return userId
+  end
+
+  function :getParticipantDetails, { id: :uint32 }, :public, :view, returns: [:string,:address,:string] do
+    return [s.participants[ id ].userName,
+            s.participants[ id ].participantAddress,
+            s.participants[ id ].participantType]
+  end
+
+  function :createProduct, { ownerId: :uint32,
+                             modelNumber: :string,
+                             partNumber: :string,
+                             serialNumber: :string,
+                             productCost: :uint32 }, :public, returns: :uint32 do     
+      require( s.participants[ ownerId ].participantType == "manufacturer",  "must be manufacturer" ) 
+      
+      productId = s.p_id += 1
+      s.products[ productId ].modelNumber  = modelNumber
+      s.products[ productId ].partNumber   = partNumber
+      s.products[ productId ].serialNumber = serialNumber
+      s.products[ productId ].cost         = productCost
+      s.products[ productId ].productOwner = s.participants[ownerId].participantAddress
+      s.products[ productId ].mfgTimestamp = block.timestamp
+      return productId
+  end
+
+  function :getProductDetails, { id: :uint32 }, :public, :view, returns: [:string,:string,:string,:uint32,:address,:timestamp] do
+      return [s.products[ id ].modelNumber,
+              s.products[ id ].partNumber,
+              s.products[ id ].serialNumber,
+              s.products[ id ].cost,
+              s.products[ id ].productOwner,
+              s.products[ id ].mfgTimestamp]
+  end
+   
+  function :transferToOwner, { user1Id: :uint32,
+                               user2Id: :uint32, 
+                               prodId: :uint32 }, :public, returns: :bool do
+        require( msg.sender == s.products[prodId].productOwner, "only owner" )
+
+        p1 = s.participants[ user1Id ]
+        p2 = s.participants[ user2Id ]
+        registrationId = s.r_id += 1
+        
+        s.registrations[ registrationId ].productId    = prodId
+        s.registrations[ registrationId ].productOwner = p2.participantAddress 
+        s.registrations[ registrationId ].ownerId      = user2Id
+        s.registrations[ registrationId ].trxTimestamp = block.timestamp
+
+        s.products[ prodId ].productOwner = p2.participantAddress
+        s.productTrack[ prodId ].push( registrationId )
+
+        emit :Transfer, prodId
+
+        return true
+  end
+  
+  function :getProductTrack, { prodId: :uint32 }, :public, :view, returns: array(:uint32) do 
+      return s.productTrack[ prodId ]
+  end
+
+  function :getRegistrationDetails, { regId: :uint32 }, :public, :view, returns: [:uint32, :uint32, :address, :timestamp] do
+      r = s.registrations[ regId ]
+
+      return [r.productId,
+              r.ownerId,
+              r.productOwner,
+              r.trxTimestamp]
+  end
+end
+```
+
+Now let's square the circle and try the impossible.
+Let's run the SupplyChain contract.
+
+
+``` ruby
+require 'rubidity'
+
+# load (parse) and generate contract classes
+Contract.load( 'SupplyChain' )
+
+#  try out contract classes
+pp SupplyChain
+pp SupplyChain.name
+
+pp SupplyChain::Transfer
+pp SupplyChain::Transfer.name
+
+pp SupplyChain::Transfer.new( productId: 111 )
+
+pp SupplyChain::Product
+pp SupplyChain::Participant
+pp SupplyChain::Registration
+pp SupplyChain::Product.name
+pp SupplyChain::Participant.name
+pp SupplyChain::Registration.name
+
+
+alice   = '0x'+'a'*40 # e.g. '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'
+bob     = '0x'+'b'*40 # e.g. '0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb'
+charlie = '0x'+'c'*40 # e.g. '0xcccccccccccccccccccccccccccccccccccccccc'
+
+pp alice
+pp bob
+pp charlie
+
+pp SupplyChain::Product.new( modelNumber: 'model1',
+                             partNumber:  'part1',
+                             serialNumber: 'serial1',
+                             productOwner: alice,
+                             cost:         1000,
+                             mfgTimestamp: 1698756267 )
+                   
+pp SupplyChain::Participant.new( userName: 'alice',
+                                 password: 'passa',
+                                 participantType: 'manufacturer',
+                                 participantAddress: alice )
+
+pp SupplyChain::Registration.new( productId:  1,  
+                                   ownerId:   1, 
+                                   productOwner: alice,
+                                   trxTimestamp: 1698756267 )                    
+
+
+contract = SupplyChain.new
+pp contract
+
+pp contract.p_id
+pp contract.u_id
+pp contract.r_id
+
+pp contract.serialize
+#=>
+# {:p_id=>0, :u_id=>0, :r_id=>0,
+#  :products=>{}, 
+#  :participants=>{}, 
+#  :registrations=>{}, 
+#  :productTrack=>{}}
+
+
+pp contract.createParticipant( name: 'alice', 
+                               pass: 'passa', 
+                               addr: alice, 
+                               type: 'manufacturer' )
+
+pp contract.createParticipant( name: 'bob', 
+                               pass: 'passb', 
+                               addr: bob, 
+                               type: 'supplier' )
+
+pp contract.createParticipant( name: 'charlie', 
+                               pass: 'passc', 
+                               addr: charlie, 
+                               type: 'consumer' )
+
+pp contract.getParticipantDetails( 1 )
+pp contract.getParticipantDetails( 2 )
+pp contract.getParticipantDetails( 3 )
+
+
+
+Runtime.block.timestamp = 1698846375
+
+pp contract.createProduct( ownerId: 1,
+                             modelNumber: 'prod1',
+                             partNumber: '100',
+                             serialNumber: '123',
+                             productCost: 11 )
+
+pp contract.getProductDetails( 1 )
+
+
+Runtime.msg.sender = alice
+Runtime.block.timestamp = 1698847541
+
+pp contract.transferToOwner( user1Id: 1,
+                             user2Id: 2, 
+                             prodId: 1 )
+
+Runtime.msg.sender = bob
+Runtime.block.timestamp = 1698848314
+
+pp contract.transferToOwner( user1Id: 2,
+                             user2Id: 3, 
+                             prodId: 1 )
+
+
+pp contract.getRegistrationDetails( 1 )
+pp contract.getRegistrationDetails( 2 )
+
+pp contract.getProductTrack( 1 )
+
+pp contract.serialize
+#=> {:p_id=>1,
+#    :u_id=>3,
+#    :r_id=>2,
+#    :products=>{1=>["prod1", "100", "123", "0xcccccccccccccccccccccccccccccccccccccccc", 11, 1698846375]},
+#   :participants=>
+#    {1=>["alice", "passa", "manufacturer", "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"],
+#     2=>["bob", "passb", "supplier", "0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"],
+#     3=>["charlie", "passc", "consumer", "0xcccccccccccccccccccccccccccccccccccccccc"]},
+#   :registrations=>
+#    {1=>[1, 2, "0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", 1698847541],
+#     2=>[1, 3, "0xcccccccccccccccccccccccccccccccccccccccc", 1698848314]},
+#   :productTrack=>{1=>[1, 2]}}
+```
+
+that's it.
+
+
+
+
+## Questions? Comments?
+
+Join us in the [Rubidity & Rubysol (community) discord (chat server)](https://discord.gg/3JRnDUap6y). Yes you can.
+Your questions and commentary welcome.
+
+Or post them over at the [Help & Support](https://github.com/geraldb/help) page. Thanks.
+

data/Rakefile

@@ -0,0 +1,30 @@
+require 'hoe'
+require './lib/rubidity/version.rb'
+
+
+Hoe.spec 'rubidity' do
+
+  self.version =  Rubysol::Module::Rubidity::VERSION
+
+  self.summary = 'rubidity gem - rubidity "classic / o.g." contract builder; trying the impossible and square the circle, that is, a rubidity "classic / o.g." dsl builder generating rubysol "more ruby-ish" contract classes'
+  self.description = summary
+
+  self.urls    = { home: 'https://github.com/s6ruby/rubidity' }
+
+  self.author  = 'Gerald Bauer'
+  self.email   = 'gerald.bauer@gmail.com'
+
+  # switch extension to .markdown for gihub formatting
+  self.readme_file  = 'README.md'
+  self.history_file = 'CHANGELOG.md'
+
+  self.extra_deps = [
+    ['rubysol', '>= 0.1.0'],
+  ]
+
+  self.licenses = ['Public Domain']
+
+  self.spec_extras = {
+    required_ruby_version: '>= 2.3'
+  }
+end

data/lib/rubidity/builder.rb

@@ -0,0 +1,215 @@
+######
+#  reading rubidity classic/o.g. "dsl"
+
+
+class Builder
+    ## auto-add extension and import path for now - why? why not?
+    def self.load_file( path )
+    code = File.open( "contracts/#{path}.rb", 'r:utf-8' ) { |f| f.read }
+    basename = File.basename( path )
+    lineno   = 1
+    load( code, basename, lineno )
+  end
+
+  ## note: try adding filename and lineno to get source for block!!!
+  def self.load( code, filename, lineno )
+
+    ## todo/fix: add filename to @paths too (to avoid possible recursive loading!!)
+
+    builder = Builder.new
+    builder.instance_eval( code, filename, lineno )
+    builder
+  end
+
+  def initialize
+    @source = Source.new
+    ## only load path once; keep track of loaded imports 
+    ##  change paths to contracts or such - why? why not?
+    @paths  = []   
+  end
+
+
+  attr_reader :source
+
+
+  ## examples:
+  ## pragma :rubidity, "1.0.0"
+  def pragma( ... )
+     ## ignore for now
+  end
+
+  ## examples:
+  ## import './ERC20'
+  def import( path )
+    puts "==> importing >#{path}<..."
+    code = File.open( "contracts/#{path}.rb", 'r:utf-8' ) { |f| f.read }
+  
+    basename = File.basename( path )
+
+    if @paths.include?( basename )
+        puts "   skipping import; already loaded"
+    else
+       @paths << basename
+       lineno   = 1  ## note: starting at line 1 (NOT 0!!!)
+       instance_eval( code, basename, lineno )
+    end
+  end
+
+
+  
+  def contract( name, is: [], abstract: false, &body )
+     contract =  ContractDef.new( name, is: is, abstract: abstract )
+     contract.instance_eval( &body )
+
+     @source.contracts << contract
+  end
+end  # class Builder
+
+
+
+class Source   ## rename to unit (source unit) or service or ?? - why? why not?
+
+   attr_reader :contracts
+
+   def initialize
+      @contracts = []
+   end
+
+   def generate
+      CodegenClassic.generate( self )
+   end
+end  # class Source
+
+
+
+class ContractDef
+   attr_reader :name, :is, :abstract, 
+               :events, :structs,
+               :storage, :functions
+   def initialize( name, is: [], abstract: false )
+      @name      = name
+      @is        = if is.is_a?( Symbol ) 
+                        [is]
+                   elsif is.is_a?( Array ) 
+                         is   
+                   else
+                     raise ArgumentError, "symbol or array expected; got #{is.inspect}"
+                   end
+      @abstract  = abstract
+      @events    = {}
+      @structs   = {}
+      @storage   = {}
+      @functions = {}
+   end 
+
+
+   def event( name, args )
+      @events[name] = args
+   end
+
+   def struct( name, args )
+      @structs[name] = args
+   end
+
+
+   [:string, 
+    :uint8, :uint32, :uint112, :uint256,
+    :address
+   ].each do |type|
+     define_method(type) do |*args|
+
+        if args.size == 0
+           ## assume type helper to convert :string to string, 
+           ##                               :address to address, and such
+           puts "  turn :#{type} into #{type}"
+           return type
+        end 
+
+
+        type = type
+        name = args.pop.to_sym
+        @storage[ name ] = { type: type, args: args }
+     end
+   end
+
+   def mapping( *args )
+        key_type, value_type = args.shift.first
+        
+        if args.last.is_a?( Symbol )
+          name = args.pop
+          @storage[ name ] = { type: :mapping, 
+                               key_type: key_type, 
+                               value_type: value_type,
+                               args: args } 
+        else
+           { type: :mapping, 
+             key_type: key_type, 
+             value_type: value_type,
+             args: args }
+        end
+   end
+
+   def array( *args )
+      sub_type = args.shift
+        
+      if args.last.is_a?( Symbol )
+        name = args.pop
+        @storage[ name ] = { type: :array,  
+                             sub_type: sub_type,
+                             args: args } 
+      else
+         { type: :array, 
+           sub_type: sub_type,
+           args: args }
+      end
+   end
+   
+
+   def function(name, args, *options, returns: nil, &body )
+      ## check if access to source is possible?
+      puts 
+      # puts "   function body: #{body.class.name}"
+      #=>  Proc
+      # body.soure
+      #=> ["(eval)", 17]  - source filename and line number
+      pp body
+      pp body.parameters
+      pp body.source_location
+      puts
+      puts  body.source 
+
+
+      ## note: for now strip names/keys if returns is a hash - why? why not?
+      ##   e.g. function :getReserves, {}, :public, :view, returns: {
+      ##             _reserve0: :uint112, 
+      ##             _reserve1: :uint112, 
+      ##             _blockTimestampLast: :uint32 }
+     
+      returns =   returns.values   if returns.is_a?( Hash )
+
+      ###
+      ## note: turn returns into an array - empty if nil, etc.
+      ##        always wrap into array
+      returns =  if returns.nil?
+                    []
+                 elsif returns.is_a?( Array ) 
+                    returns 
+                 else ## assume single type
+                    [returns]  
+                 end  
+
+      @functions[ name ] = { args: args,
+                            options: options,
+                            returns: returns,
+                            body: body.source }
+   end
+  
+   def constructor(args = {}, *options, &body)
+     function(:constructor, args, *options, returns: nil, &body )
+   end
+end  # class ContractDef
+
+
+
+
+

data/lib/rubidity/codegen.rb

@@ -0,0 +1,203 @@
+#####
+#  codegen - code generator
+
+##
+## require(s.balanceOf[msg.sender] >= amount, 'Insufficient balance')
+##    
+## s.balanceOf[msg.sender] -= amount
+## s.balanceOf[to] += amount
+## 
+## emit :Transfer, from: msg.sender, to: to, amount: amount
+
+def patch( src )
+    ## change require() to assert
+    src = src.gsub( /\brequire\b/, 'assert' )
+ 
+    ## s. to ivars (@)
+    src = src.gsub( /\bs\./, '@' )
+ 
+    ## change emit :  to log
+    src = src.gsub( /\bemit[ ]+:/, 'log ' )
+    src
+end
+ 
+ 
+
+## "built-in" types by "classic" symbol lookup
+
+   ## storage decimals{:type=>:uint8, :args=>[:public]}
+    ## storage totalSupply{:type=>:uint256, :args=>[:public]}
+    ## storage balanceOf{:type=>:mapping, :key_type=>:address, :value_type=>:uint256, :args=>[:public]}
+    ## storage allowance{:type=>:mapping,
+    ##                   :key_type=>:address,
+    ##   :value_type=>{:type=>:mapping, :key_type=>:address, :value_type=>:uint256, :args=>[]},
+ 
+def spec_to_type( spec, structs: {} )
+  type = spec.is_a?( Symbol ) ? spec : spec[:type] 
+
+  ## check structs first
+  struct_class = structs[ type ]
+  if struct_class
+    puts "  found struct class >#{type}<:"
+    pp struct_class
+    return struct_class
+  end
+
+  case type  
+  when :uint8, :uint32, :uint112, :uint224, :uint256  then Types::UInt
+  when :address   then Types::Address
+  when :string    then Types::String
+  when :bytes     then Types::Bytes
+  when :timestamp then Types::Timestamp
+  when :bool      then Bool   ## note: Bool is always "global" - why? why not?
+  when :mapping   then mapping( spec_to_type( spec[:key_type], structs: structs ), 
+                                spec_to_type( spec[:value_type], structs: structs ) )                                
+  when :array     then array( spec_to_type( spec[:sub_type], structs: structs ))
+  else
+    raise ArgumentError, "unknown type - #{type}" 
+  end
+end
+
+
+
+##
+#  use static methods for now  - why? why not?
+class CodegenClassic
+
+   
+def self.generate( source )
+    pp source
+
+    contract_classes = {}  ## lookup by name
+    struct_classes = {}   ## lookup by name
+
+source.contracts.each do |contract|
+    puts "==> generate contract #{contract.name}..."
+    base =  contract.is.empty? ? Contract : contract_classes[contract.is[0]]
+    puts "  base: #{base}"
+    pp contract.is
+
+    contract_class = Class.new( base )
+
+    ## Use Kernel / global ?? scope for now
+    scope = Object
+    scope.const_set( contract.name, contract_class )
+    contract_classes[ contract.name ] = contract_class
+
+    ## add events if any
+    ##
+    ## event :Transfer, { from: :address, to: :address, amount: :uint256 }
+    ## event :Approval, { owner: :address, spender: :address, amount: :uint256 }
+    ##
+    ## event Transfer {:from=>:address,  :to=>:address,      :amount=>:uint256}
+    ## event Approval {:owner=>:address, :spender=>:address, :amount=>:uint256}
+    contract.events.each do |event_name, event_args|
+        print "event #{event_name}"
+        pp event_args
+
+        attributes = event_args.map { |name, type| [name, spec_to_type(type)] }.to_h 
+        pp attributes
+        contract_class.event( event_name, **attributes ) 
+    end
+
+    ## add structs if any
+    contract.structs.each do |struct_name, struct_args|
+        print "struct #{struct_name}"
+        pp struct_args
+
+        attributes = struct_args.map { |name, type| [name, spec_to_type(type)] }.to_h 
+        pp attributes
+        struct_class = contract_class.struct( struct_name, **attributes ) 
+
+        struct_classes[ struct_name ] = struct_class
+    end
+
+
+    ## add storage/state if any
+    ##
+    ## storage name{:type=>:string, :args=>[:public]}
+    ## storage symbol{:type=>:string, :args=>[:public]}
+    ## storage decimals{:type=>:uint8, :args=>[:public]}
+    ## storage totalSupply{:type=>:uint256, :args=>[:public]}
+    ## storage balanceOf{:type=>:mapping, :key_type=>:address, :value_type=>:uint256, :args=>[:public]}
+    ## storage allowance{:type=>:mapping,
+    ##                   :key_type=>:address,
+    ##   :value_type=>{:type=>:mapping, :key_type=>:address, :value_type=>:uint256, :args=>[]},
+    ##    :args=>[:public]}
+    contract.storage.each do |storage_name, storage_args|
+        print "storage #{storage_name}"
+        pp storage_args
+ 
+        kwargs = {
+            storage_name => spec_to_type( storage_args, structs: struct_classes )
+        }
+        contract_class.storage( **kwargs ) 
+    end
+
+
+    ## add functions if any
+    ## constructor:
+    ##  {:args=>{:name=>:string, :symbol=>:string, :decimals=>:uint8},
+    ##   :options=>[],
+    ##   :body=>"..."}
+    ## function approve:
+    ##  {:args=>{:spender=>:address, :amount=>:uint256},
+    ##   :options=>[:public, :virtual],
+    ##   :returns=>[:bool],
+    ##   :body=>"..."}
+    ## function transfer:
+    ##  {:args=>{:to=>:address, :amount=>:uint256},
+    ##   :options=>[:public, :virtual],
+    ##   :returns=>[:bool],
+    ##   :body=>"..."}
+    contract.functions.each do |function_name, function_args|
+        print "function #{function_name}"
+        pp function_args
+
+        input_types = function_args[:args].values.map { |type| spec_to_type(type) } 
+      
+        kwargs  = function_args[:args].keys.map {|arg| "#{arg}:" }.join( ', ' )
+        puts "  kwargs: #{kwargs}"
+        body    = function_args[:body]
+        body    = patch( body )  ## use ruby-ish conventions
+      
+
+        if function_name == :constructor 
+          puts "==> add constructor..."
+          contract_class.sig input_types
+          ## add unsafe method
+          
+          code =<<RUBY
+            def constructor( #{kwargs} ) 
+               puts "==> calling #{contract_class.name}.constructor..."
+               puts "  self: \#{self.class.name}"
+               #{body}
+            end
+RUBY
+          puts "  code:"
+          puts code
+          contract_class.class_eval( code )
+        else
+           output_types = function_args[:returns].map { |type| spec_to_type(type) } 
+           
+           puts "==> add #{function_name}..."
+           contract_class.sig input_types, returns: output_types
+           ## add unsafe method
+
+           code =<<RUBY
+           def #{function_name}( #{kwargs} ) 
+              puts "==> calling #{contract_class.name}.#{function_name}..."
+              puts "  self: \#{self.class.name}"
+              #{body}
+           end
+RUBY
+         puts "  code:"
+         puts code
+         contract_class.class_eval( code )
+        end
+    end
+end
+end # method self.generate
+
+end # class CodegenClassic
+

data/lib/rubidity/proc.rb

@@ -0,0 +1,42 @@
+
+
+class Proc
+  ## add quick & dirty support for getting source!!!  
+
+  ## use non-greed .*? to "slurp"-up everything to the end
+  BLOCK_RX = /do 
+               .*? 
+              \n[ ]{0,2}end
+              /xm
+
+  def source   ## fix: change to contract_source - why? why not?
+     filename, lineno = self.source_location
+     lines = File.open( "contracts/#{filename}.rb", 'r:utf-8' ) { |f| f.readlines }
+     ## up to 10 for now
+     ## note: lineno is starting counting at 1 (use -1 for offset in ary)
+
+     ## for now assume no method longer than 100 lines
+     ## note: lines INCLUDEs newlines e.g.
+     ##  ["  constructor(name: :string, symbol: :string, decimals: :uint8) do |name, symbol, decimals|\n",
+     ##   "    puts \"ERC20.constructor\"\n",
+     ##   "    @name = name\n",
+     ##   "    @symbol = symbol\n",
+     ##   "    @decimals = decimals\n",
+     ##   "  end\n",
+
+     pastie = lines[lineno-1, 100].join
+     ## pp pastie
+     
+     ## use regex quick hack
+     ##   to extract use first do
+     ##  and end on its own line (with max indent of two spaces!!)
+     m = BLOCK_RX.match( pastie )
+     if m
+        m[0][2..-1][0..-4]  ## return matched code - cut of do/end wrapper
+     else
+        raise  "sorry; no do-end match for code block source"
+     end 
+  end  
+end
+
+

data/lib/rubidity/version.rb

@@ -0,0 +1,23 @@
+module Rubysol
+  module Module
+    module Rubidity
+      MAJOR = 0
+      MINOR = 9
+      PATCH = 0
+      VERSION = [MAJOR,MINOR,PATCH].join('.')
+    
+      def self.version
+        VERSION
+      end
+    
+      def self.banner
+        "rubidity/#{VERSION} on Ruby #{RUBY_VERSION} (#{RUBY_RELEASE_DATE}) [#{RUBY_PLATFORM}] in (#{root})"
+      end
+    
+      def self.root
+        File.expand_path( File.dirname(File.dirname(File.dirname(File.dirname(__FILE__)))) )
+      end
+    
+    end # module Rubidity
+  end # module Module
+end # module Rubysol

data/lib/rubidity.rb

@@ -0,0 +1,42 @@
+
+require 'solidity/typed'
+require 'rubysol'
+
+
+## our own code
+require_relative 'rubidity/version'  # let version always go first
+require_relative 'rubidity/proc'
+require_relative 'rubidity/builder'
+require_relative 'rubidity/codegen'
+
+
+
+###
+# for easy use / convenience
+#     pack everything into Contract.load( path/name ) 
+
+class Contract
+  def self.load( path, generate: true )
+
+    source = Builder.load_file( path ).source
+    pp source
+    pp source.contracts
+    
+    puts "  #{source.contracts.size} contract(s) in source (unit):"
+    source.contracts.each do |contract|
+        print "   #{contract.name}"
+        print " is #{contract.is.inspect}"   unless contract.is.empty?
+        print "\n"
+    end
+    
+    ####################
+    ### generate contract classes
+    source.generate   if generate
+     
+    source  ## return source (unit) - why? why not?   
+  end
+end   # class Contract
+
+
+
+puts Rubysol::Module::Rubidity.banner     ## say hello

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification
+name: rubidity
+version: !ruby/object:Gem::Version
+  version: 0.9.0
+platform: ruby
+authors:
+- Gerald Bauer
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-11-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rubysol
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
+- !ruby/object:Gem::Dependency
+  name: hoe
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+description: rubidity gem - rubidity "classic / o.g." contract builder; trying the
+  impossible and square the circle, that is, a rubidity "classic / o.g." dsl builder
+  generating rubysol "more ruby-ish" contract classes
+email: gerald.bauer@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- CHANGELOG.md
+- Manifest.txt
+- README.md
+files:
+- CHANGELOG.md
+- Manifest.txt
+- README.md
+- Rakefile
+- lib/rubidity.rb
+- lib/rubidity/builder.rb
+- lib/rubidity/codegen.rb
+- lib/rubidity/proc.rb
+- lib/rubidity/version.rb
+homepage: https://github.com/s6ruby/rubidity
+licenses:
+- Public Domain
+metadata: {}
+post_install_message:
+rdoc_options:
+- "--main"
+- README.md
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key:
+specification_version: 4
+summary: rubidity gem - rubidity "classic / o.g." contract builder; trying the impossible
+  and square the circle, that is, a rubidity "classic / o.g." dsl builder generating
+  rubysol "more ruby-ish" contract classes
+test_files: []