solidity 0.1.2 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2450cdadc297a615031d2a910fc70e39b6a29514ee4387e532bb3a7febec7fb4
-  data.tar.gz: 572f8c43f7cc641fc3d970b00287eec3e9adf7412ad046950d0bfa116930822c
+  metadata.gz: 3920e32ab53156b256507811437d64f62f38bd42472aecb5c51a4fd3eb2f57e1
+  data.tar.gz: 4a5c36c583ba102881417af5d184c6351ef9d6a1f20154ab6096fb4722694bc6
 SHA512:
-  metadata.gz: 2cdb28abe2cafb57f53df2d07af8a61c0f4c80177b0267bd7de2fa1afb96d423ff2399d628f11f34edd6896eaaeb4af3ebed5aa2b3489817c49c20560a536818
-  data.tar.gz: bcef0cdea7f22b7960db8269738d612d6a51f46626560762e8e85ffd52dc343e8a3d652de74b1d4c6ca89ee98fe7a1066a4de85535b5c704e1d6aa732bef7033
+  metadata.gz: b7227cdec56deceba0230c0f8946ea0182e2e144919bb2b0227d52a19c4085d89a0b2f3a62c796b162c9fba59880d5ee1cb154bfc0f5de1455cb4bd353d4602d
+  data.tar.gz: 9840c43aade93aaec0b0222c2db7dc4f50246565da9e52c69363fe599e43bed8e0e800ac31349a846ab7cfeb4e28126bde9fcfd8d6a85b884d9d26240b1fc35b

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,12 +27,34 @@ 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
 
 Get / generate outline from source in the solidity (`.sol`) contract programming language:
-
 ```ruby
 [
  "0x34625ecaa75c0ea33733a05c584f4cf112c10b6b",
@@ -52,6 +91,36 @@ library Base64
 ```
 
 
+Note:  The outline includes:
+
+1. contract definitions e.g.
+
+    contract NounsDescriptor is INounsDescriptor, Ownable
+
+2. abstract contract definitions e.g.
+
+    abstract contract Ownable is Context
+    abstract contract Context
+
+3. library definitions e.g.
+
+    library Strings
+    library NFTDescriptor
+    library MultiPartRLEToSVG
+    library Base64
+
+4. interface definitions e.g.
+
+    interface INounsDescriptor
+    interface INounsSeeder
+
+
+
+
+<!-- break -->
+
+More outline samples:
+
 ```
 outline:
 contract Indelible is ERC721A, ReentrancyGuard, Ownable
@@ -96,6 +165,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,217 @@
+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!
+
+
+  ## from the solidity grammar
+  ##
+  ## StringLiteralFragment
+  ##  : 'unicode'? '"' DoubleQuotedStringCharacter* '"'
+  ##  | 'unicode'? '\'' SingleQuotedStringCharacter* '\'' ;
+  ##
+  ## fragment
+  ## DoubleQuotedStringCharacter
+  ##   : ~["\r\n\\] | ('\\' .) ;
+  ##
+  ## fragment
+  ## SingleQuotedStringCharacter
+  ##   : ~['\r\n\\] | ('\\' .) ;
+
+
+  SINGLE_QUOTE       = %r{'
+                           ( \\\\. | [^'] )*
+                         '}x
+
+  DOUBLE_QUOTE       = %r{"
+                           ( \\\\. | [^"] )*
+                          "}x
+
+
+  ## from the solidity grammar
+  ##  > An identifier in solidity has to start with a letter,
+  ##  >  a dollar-sign or an underscore and
+  ##  >  may additionally contain numbers after the first symbol.
+  ##
+  ## Identifier
+  ##   : IdentifierStart IdentifierPart* ;
+  ##
+  ##  fragment
+  ##    IdentifierStart
+  ##    : [a-zA-Z$_] ;
+  ##
+  ##  fragment
+  ##    IdentifierPart
+  ##   : [a-zA-Z0-9$_] ;
+
+   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
+
+
+  ## from the solidity grammar
+  ##
+  ## COMMENT
+  ##   : '/*' .*? '*/'  ;
+  ##
+  ## LINE_COMMENT
+  ##   : '//' ~[\r\n]* ;
+
+
+
+   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 = 2
+  PATCH = 4
   VERSION = [MAJOR,MINOR,PATCH].join('.')
 
   def self.version

data/lib/solidity.rb

@@ -3,184 +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 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
-                                         | $
-                                         | (?=['"])
-                                         | (?=\/(\/|\*))
-                                         | (?=pragma\b)
-                                         | (?=contract\b)
-                                         | (?=abstract\b)
-                                         | (?=library\b)
-                                         | (?=interface\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
-
-
-
 puts Solidity.banner    ## say hello

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: solidity
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.4
 platform: ruby
 authors:
 - Gerald Bauer
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-01-30 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: