solidity 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e72e223ba2202849d7dbb405a56b1edf7345b911813b3449bbf2059a9ebe87e5
-  data.tar.gz: 2aa7d53cc55bc04929440cb3c49c99b85cc3efe0a151d24f9b887c2ac6297f09
+  metadata.gz: 7a34efb053c8fd9211832cedb2a99a05362f10fb3e43323d6bca7cd69783a88d
+  data.tar.gz: 3e113d90344d4a4745836b3b8bea5f18f4ac3c621d56914e5610c331f25dba20
 SHA512:
-  metadata.gz: 25a530da83da24bbbf6ae85bc97a4ecac8d27eb0745d2952f3f43fda6ad3422021d798edffcafc9e03afcf6bd6d0c7985103fec52caa34987ffdb5d84a8699fd
-  data.tar.gz: '09339328d15e47d6d9a6345f000cbc1dee7fce14dee04e14765f82add73824dbce6fa41ba0dfe1a190059b5aeef93b6c27dc3acf759f67bb0348556098f127e5'
+  metadata.gz: ea91690f94b665991f5f2e6934def21c1dd70ac475efc1e6cd578d84a05e31a7437dac0c1c3f9bffecb1283655ba3454d663f04a4ff190246ce240b4ea900535
+  data.tar.gz: f8b3f08e0691d3cfc34b25ab6652a632f41df90a6d0d593f699971886301a329fcb4f6fac048d3d041432d446030b89338cf9cabd01239a00a4a69aa50de9c45

data/Manifest.txt

@@ -3,4 +3,5 @@ Manifest.txt
 README.md
 Rakefile
 lib/solidity.rb
+lib/solidity/parser.rb
 lib/solidity/version.rb

data/README.md

@@ -1,3 +1,20 @@
+
+---
+
+_The Ruby Programming Language for Contract / Transaction Scripts on the Blockchain World Computer - Yes, It's Just Ruby_
+
+**sruby - Small, Smart, Secure, Safe, Solid & Sound (S6) Ruby**
+
+sruby is a subset of mruby that is a subset of "classic" ruby.
+
+
+For more see the [**Red Paper »**](https://github.com/s6ruby/redpaper)
+
+---
+
+
+
+
 # Solidity
 
 solidity gem - (fuzzy) parser for (crypto) contracts for ethereum & co.
@@ -10,6 +27,29 @@ solidity gem - (fuzzy) parser for (crypto) contracts for ethereum & co.
 
 
 
+## New to the Solidity (Contract) Programming Language?
+
+_Official_
+
+Solidity Language @ <https://soliditylang.org>
+
+- Read the Docs @ <https://docs.soliditylang.org/en/latest/>
+- Blog @  <https://blog.soliditylang.org>
+- Forum @ <https://forum.soliditylang.org>
+- Source @ <https://github.com/ethereum/solidity>
+
+<!-- break -->
+
+_More_
+
+Solidity by Example @ <https://solidity-by-example.org>
+
+Learn X in Y Minutes (Where X=Solidity) @ <https://learnxinyminutes.com/docs/solidity>
+
+Awesome Solidity @ <https://github.com/bkrem/awesome-solidity>
+
+
+
 
 
 ## Usage
@@ -24,9 +64,7 @@ Get / generate outline from source in the solidity (`.sol`) contract programming
 ].each do |addr|
 
   path = "awesome-contracts/address/#{addr}/contract.sol"
-  txt = read_text( path )
-
-  parser = Solidity::Parser.new( txt )
+  parser = Solidity::Parser.read( path )
 
   puts "---"
   puts "outline:"
@@ -67,6 +105,7 @@ library Address
 library Base64
 abstract contract Context
 library MerkleProof
+interface ERC721A__IERC721Receiver
 contract ERC721A is IERC721A
 interface IERC721A
 ```
@@ -97,6 +136,15 @@ library EnumerableSet
 
 
 
+
+## Bonus: Solidity (Fuzzy) Parser in the Wild / Real-World
+
+See [**Awesome (Ethereum) Contracts @ Open Blockchains »**](https://github.com/openblockchains/awesome-contracts)
+
+Add your usage here. Yes, you can.
+
+
+
 ## License
 
 The `solidity` scripts are dedicated to the public domain.

data/Rakefile

@@ -1,6 +1,15 @@
 require 'hoe'
 require './lib/solidity/version.rb'
 
+
+###
+# hack/ quick fix for broken intuit_values - overwrite with dummy
+class Hoe
+  def intuit_values( input ); end
+end
+
+
+
 Hoe.spec 'solidity' do
 
   self.version = Solidity::VERSION

data/lib/solidity/parser.rb

@@ -0,0 +1,173 @@
+module Solidity
+
+class Parser
+
+   def self.read( path )
+      txt = read_text( path )
+      new( txt )
+   end
+
+
+
+   def initialize( txt )
+     @txt = txt
+   end
+
+
+  ###############
+  ## quotes
+  ##
+  ## note: regex pattern \\ needs to get escaped twice, thus, \\.
+  ##  and for literal \\ use \\\\\.
+
+  ## => \\\\.    --  allow backslash escapes e.g. \n \t \\ etc.
+  ## => [^`]     --  everything except backquote
+
+  ## todo/fix - check if [^`] includes/matches newline too (yes)? -- add \n for multi-line!
+
+  SINGLE_QUOTE       = %r{'
+                           ( \\\\. | [^'] )*
+                         '}x
+
+  DOUBLE_QUOTE       = %r{"
+                           ( \\\\. | [^"] )*
+                          "}x
+
+
+   NAME                    = /[a-zA-Z][a-zA-Z0-9_]*/
+   END_OF_LINE             = /\n|$/
+   ## inline comments (multi- or end-of-line)
+   END_OF_LINE_OR_COMMENT_OR_KEYWORD_OR_QUOTE  = / \n
+                                         | $
+                                         | (?=['"])
+                                         | (?=\/(\/|\*))
+                                         | (?=\bpragma\b)
+                                         | (?=\bcontract\b)
+                                         | (?=\babstract\b)
+                                         | (?=\blibrary\b)
+                                         | (?=\binterface\b)
+                                       /x
+
+
+   def _norm_whitespace( str )
+      ## change newlines to spaces and
+      ##   all multiple spaces to one
+      str = str.gsub( /[ \t\n\r]+/, ' ' )
+      str.strip
+   end
+
+   def _quick_pass_one
+     ## note:  CANNOT handle inline comments
+     ##           in pragma, contract, etc.  (get "silently" slurped)
+     ##         report a parse error - if comments slurped - why? why not?
+     ##
+
+
+     tree = []
+
+     s = StringScanner.new( @txt )
+
+     loop do
+       s.skip( /[ \t]+/ )  ## note: do NOT skip newlines here; pass along blank/empty lines for now - why? why not?
+       if s.check( "'" )   ## single-quoted string
+          str = s.scan( SINGLE_QUOTE )
+          tree << [:string, str]
+       elsif s.check( '"' )  ## double-quoted string
+          str = s.scan( DOUBLE_QUOTE )
+          tree << [:string, str]
+       elsif s.check( '/*' )
+          comment = s.scan_until( /\*\// )
+          ## print "multi-line comment:"
+          ## pp comment
+          tree << [:comment, comment]
+       elsif s.check( '//' )
+          comment = s.scan_until( END_OF_LINE ).rstrip
+          ## print "comment:"
+          ## pp comment
+          tree << [:comment, comment]
+       else
+          name = s.check( NAME )
+          case name
+          when 'pragma'
+             code = s.scan_until( /;/ )
+             code = _norm_whitespace( code )
+             ## print "pragma:"
+             ## pp code
+             tree << [:pragma, code]
+          when 'contract'
+             code = s.scan_until( /(?=\{)/ )
+             code = _norm_whitespace( code )
+             ## print "contract:"
+             ## pp code
+             tree << [:contract, code]
+          when 'abstract'
+            code = s.scan_until( /(?=\{)/ )
+            code = _norm_whitespace( code )
+            ## print "abstract contract:"
+            ## pp code
+            tree << [:abstract_contract, code]
+         when 'library'
+            code = s.scan_until( /(?=\{)/ )
+            code = _norm_whitespace( code )
+            ## print "library:"
+            ## pp code
+            tree << [:library, code]
+          when 'interface'
+            code = s.scan_until( /(?=\{)/ )
+            code = _norm_whitespace( code )
+            ## print "interface:"
+            ## pp code
+            tree << [:interface, code]
+          else
+            ## slurp chunk ,that is, until newline or comment or tracked keyword
+            chunk = s.scan_until( END_OF_LINE_OR_COMMENT_OR_KEYWORD_OR_QUOTE ).rstrip
+            ## puts "chunk: >#{chunk.inspect}<"
+            tree << chunk
+          end
+       end
+       break if s.eos?
+      end
+
+     tree
+   end
+
+
+   def outline
+      buf = String.new( '' )
+      tree = _quick_pass_one
+
+      tree.each do |node|
+         if node.is_a?( Array )
+            case node[0]
+            when :contract           then  buf << node[1] << "\n"
+            when :abstract_contract  then  buf << node[1] << "\n"
+            when :interface          then  buf << node[1] << "\n"
+            when :library            then  buf << node[1] << "\n"
+            else
+            end
+         end
+      end
+
+      buf
+   end
+
+   def pragmas
+      buf = String.new( '' )
+      tree = _quick_pass_one
+
+      tree.each do |node|
+         if node.is_a?( Array )
+            case node[0]
+            when :pragma             then  buf << node[1] << "\n"
+            end
+         end
+      end
+
+      buf
+   end
+
+
+end  # class Parser
+
+
+end  # module Solidity

data/lib/solidity/version.rb

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

data/lib/solidity.rb

@@ -3,126 +3,9 @@ require 'cocos'
 
 ## our own code
 require_relative 'solidity/version'    # note: let version always go first
+require_relative 'solidity/parser'
 
 
 
 
-module Solidity
-
-class Parser
-   def initialize( txt )
-     @txt = txt
-   end
-
-
-   SINGLE_COMMENT_RX         = %r{^[ ]*//}
-   MULTI_COMMENT_BEGIN_RX    = %r{^[ ]*/\*}
-   MULTI_COMMENT_END_RX      = %r{\*/[ ]*$}
-
-   ID = '[a-zA-Z][a-zA-Z0-9]*'
-
-   PRAGMA_RX            = %r{^[ ]*pragma}
-   LIBRARY_RX           = %r{^[ ]*library[ ]+(?<id>#{ID})[ \{]}
-   ABSTRACT_CONTRACT_RX = %r{^[ ]*abstract[ ]+contract[ ]+(?<id>#{ID})[ \{]}
-   CONTRACT_RX          = %r{^[ ]*contract[ ]+(?<id>#{ID})[ \{]}
-   INTERFACE_RX         = %r{^[ ]*interface[ ]+(?<id>#{ID})[ \{]}
-
-
-   def _quick_pass_one
-     tree = []
-     node = nil
-
-     inside_comment = false
-
-     @txt.each_line do |line|
-         line = line.chomp ## remove trailing newline
-         ## pp line
-
-         if inside_comment
-            node[1] << line
-            if  MULTI_COMMENT_END_RX.match( line )
-               tree << node
-               inside_comment = false
-            end
-         else
-           if SINGLE_COMMENT_RX.match( line )   #  end-of-line comments
-               line = line.strip  ## remove leading & trailing spaces
-               ## note: fold end-of-line comments into a block (if not separated by newline)
-               node = tree[-1]
-               if  node.is_a?( Array ) &&
-                   node[0] == :comment && node[1][0].start_with?( '//' )
-                  node[1] << line
-               else
-                 tree << [:comment, [line]]
-               end
-           elsif MULTI_COMMENT_BEGIN_RX.match( line )
-              inside_comment = true
-              node = [:comment, [line]]
-           elsif PRAGMA_RX.match( line )
-              line = line.strip
-              tree << [:pragma, line]
-           elsif LIBRARY_RX.match( line )
-              line = line.strip
-              tree << [:library, line]
-           elsif ABSTRACT_CONTRACT_RX.match( line )
-              line = line.strip
-              tree << [:abstract_contract, line]
-           elsif CONTRACT_RX.match( line )
-              line = line.strip
-              tree << [:contract, line]
-           elsif INTERFACE_RX.match( line )
-              line = line.strip
-              tree << [:interface, line]
-           else
-              tree << line
-           end
-         end
-     end # each_line
-
-     tree
-   end
-
-
-   def outline
-      buf = String.new( '' )
-      tree = _quick_pass_one
-
-      tree.each do |node|
-         if node.is_a?( Array )
-            case node[0]
-            when :contract           then  buf << node[1] << "\n"
-            when :abstract_contract  then  buf << node[1] << "\n"
-            when :interface          then  buf << node[1] << "\n"
-            when :library            then  buf << node[1] << "\n"
-            else
-            end
-         end
-      end
-
-      buf
-   end
-
-   def pragmas
-      buf = String.new( '' )
-      tree = _quick_pass_one
-
-      tree.each do |node|
-         if node.is_a?( Array )
-            case node[0]
-            when :pragma             then  buf << node[1] << "\n"
-            end
-         end
-      end
-
-      buf
-   end
-
-
-end  # class Parser
-
-
-end  # module Solidity
-
-
-
 puts Solidity.banner    ## say hello

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: solidity
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
 platform: ruby
 authors:
 - Gerald Bauer
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-01-29 00:00:00.000000000 Z
+date: 2023-02-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cocos
@@ -72,6 +72,7 @@ files:
 - README.md
 - Rakefile
 - lib/solidity.rb
+- lib/solidity/parser.rb
 - lib/solidity/version.rb
 homepage: https://github.com/rubycocos/blockchain
 licenses: