tealrb 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4ebe163f8903cf66046698ddfebe36e615359bd568e76be4eb30f368011b1ce0
-  data.tar.gz: 64db7183fe7b170d7b80881cd66272e5016e6a50cb6886a5300df729520d539d
+  metadata.gz: 94ca888a944ccee0517d5e543498570af448a9eb3ea1ba74d3d3261ffc4b86f0
+  data.tar.gz: 54ac7826a7af43fb82fa17cf010a2ce869511546067f7a151181b86d3445b0bf
 SHA512:
-  metadata.gz: 94f4791ca50e11afb7937670b976a87f75aaeaa4b364e5eea104541c571fce4f2b41e73c05c7d743772fb37657cf9dc3690e869d49007b3bd77ea4c5168ff1e5
-  data.tar.gz: f77f3513679a82d255a8a1e10cc51c8e593b66d0faae844df461a36d50b211a62b5cd9761a93c1f34591b375439766eba38238f4670a7205cc00eb72bd553c57
+  metadata.gz: 4f986ae5a4e3c37460142951923c3908ec95b58d0d91f695a49a07f8e8eee062499d496b185e1f2eafec8ed2020ca9d83a4c8c50c97531a8a67e26057e7bb794
+  data.tar.gz: c73f78d20f1c76ccc41e42450f713b14dc42049d8d44ee1498c59e38cda3e7699e4f1e655932f5b86c68d707d1a1abba7d59fc5c92244552236bb2a472a3d4c2

data/lib/tealrb/contract.rb

@@ -6,6 +6,7 @@ module TEALrb
     include Opcodes
     include ABI
     include Rewriters
+    include MaybeOps
 
     attr_reader :teal
 
@@ -69,7 +70,8 @@ module TEALrb
     # sets the `#pragma version`, defines teal methods, and defines subroutines
     def initialize
       @teal = TEAL.new ["#pragma version #{self.class.version}"]
-      @scratch = Scratch.new(@teal)
+      IfBlock.id = 0
+      @scratch = Scratch.new
 
       self.class.subroutines.each_key do |name|
         define_singleton_method(name) do |*_args|
@@ -96,8 +98,6 @@ module TEALrb
     # @param definition [Lambda, Proc, UnboundMethod] the method definition
     # @return [nil]
     def define_teal_method(name, definition)
-      @teal.set_as_current
-
       new_source = generate_method_source(name, definition)
 
       define_singleton_method(name) do |*_args|
@@ -112,13 +112,11 @@ module TEALrb
     # @param definition [Lambda, Proc, UnboundMethod] the method definition
     # @return [nil]
     def define_subroutine(name, definition)
-      @teal.set_as_current
-
       define_singleton_method(name) do |*_args|
         callsub(name)
       end
 
-      @teal << 'b main' unless @teal.include? 'b main'
+      TEAL.instance << 'b main' unless TEAL.instance.include? 'b main'
 
       label(name) # add teal label
 
@@ -140,17 +138,17 @@ module TEALrb
     def comment(content, inline: false)
       content = " #{content}" unless content[0] == ' '
       if inline
-        last_line = @teal.pop
-        @teal << "#{last_line} //#{content}"
+        last_line = TEAL.instance.pop
+        TEAL.instance << "#{last_line} //#{content}"
       else
-        @teal << "//#{content}"
+        TEAL.instance << "//#{content}"
       end
     end
 
     # inserts a string into TEAL source
     # @param string [String] the string to insert
     def placeholder(string)
-      @teal << string
+      TEAL.instance << string
     end
 
     # the hash of the abi description
@@ -162,15 +160,13 @@ module TEALrb
     # @param string [String] string to transpile
     # @return [nil]
     def compile_string(string)
-      @teal.set_as_current
       eval_tealrb(rewrite(string), debug_context: 'compile_string')
       nil
     end
 
     # transpiles #main
     def compile
-      @teal.set_as_current
-      @teal << 'main:' if @teal.include? 'b main'
+      TEAL.instance << 'main:' if TEAL.instance.include? 'b main'
       eval_tealrb(rewrite(method(:main).source, method_rewriter: true), debug_context: 'main')
     end
 
@@ -227,7 +223,7 @@ module TEALrb
     end
 
     def eval_tealrb(s, debug_context:)
-      pre_teal = Array.new @teal
+      pre_teal = Array.new TEAL.instance
 
       if self.class.debug
         puts "DEBUG: Evaluating the following code (#{debug_context}):"
@@ -239,7 +235,7 @@ module TEALrb
 
       if self.class.debug
         puts "DEBUG: Resulting TEAL (#{debug_context}):"
-        puts Array.new(@teal) - pre_teal
+        puts Array.new(TEAL.instance) - pre_teal
         puts ''
       end
     rescue SyntaxError, StandardError => e

data/lib/tealrb/if_block.rb

@@ -6,39 +6,38 @@ module TEALrb
       attr_accessor :id
     end
 
-    @id = {}.compare_by_identity
+    @id = 0
 
-    def initialize(teal, _cond, &blk)
-      self.class.id[teal] ||= 0
-      @teal = teal
+    def initialize(_cond, &blk)
+      self.class.id ||= 0
       @else_count = 0
-      @id = self.class.id[@teal]
+      @id = self.class.id
       @end_label = "if#{@id}_end:"
 
-      self.class.id[@teal] += 1
+      self.class.id += 1
 
-      @teal << "bz if#{@id}_else0"
+      TEAL.instance << "bz if#{@id}_else0"
       blk.call
-      @teal << "b if#{@id}_end"
-      @teal << "if#{@id}_else0:"
-      @teal << @end_label
+      TEAL.instance << "b if#{@id}_end"
+      TEAL.instance << "if#{@id}_else0:"
+      TEAL.instance << @end_label
     end
 
     def elsif(_cond, &blk)
       @else_count += 1
-      @teal.delete @end_label
-      @teal << "bz if#{@id}_else#{@else_count}"
+      TEAL.instance.delete @end_label
+      TEAL.instance << "bz if#{@id}_else#{@else_count}"
       blk.call
-      @teal << "b if#{@id}_end"
-      @teal << "if#{@id}_else#{@else_count}:"
-      @teal << @end_label
+      TEAL.instance << "b if#{@id}_end"
+      TEAL.instance << "if#{@id}_else#{@else_count}:"
+      TEAL.instance << @end_label
       self
     end
 
     def else(&blk)
-      @teal.delete @end_label
+      TEAL.instance.delete @end_label
       blk.call
-      @teal << @end_label
+      TEAL.instance << @end_label
     end
   end
 end

data/lib/tealrb/opcode_modules.rb

@@ -33,7 +33,7 @@ module TEALrb
         private
 
         def txn_type_int(type)
-          TEALrb::TEAL.current[Thread.current] << "int #{type}"
+          TEAL.instance << "int #{type}"
         end
       end
 
@@ -603,7 +603,6 @@ module TEALrb
       extend AppFields
 
       def self.opcode(field, app_id = nil)
-        @teal = TEALrb::TEAL.current[Thread.current]
         app_params_get field, app_id
       end
     end
@@ -613,7 +612,6 @@ module TEALrb
       extend AssetFields
 
       def self.opcode(field, asset = nil)
-        @teal = TEALrb::TEAL.current[Thread.current]
         asset_params_get field, asset
       end
     end
@@ -623,7 +621,6 @@ module TEALrb
       extend AccountFields
 
       def self.opcode(field, account = nil)
-        @teal = TEALrb::TEAL.current[Thread.current]
         acct_params_get field, account
       end
     end
@@ -642,7 +639,6 @@ module TEALrb
       extend Opcodes
 
       def self.opcode(field, index)
-        @teal = TEALrb::TEAL.current[Thread.current]
         gtxn index, field
       end
 
@@ -672,7 +668,6 @@ module TEALrb
       end
 
       def [](index)
-        @teal = TEALrb::TEAL.current[Thread.current]
         txna @field, index
       end
     end
@@ -704,7 +699,6 @@ module TEALrb
       extend GlobalFields
 
       def self.opcode(field)
-        @teal = TEALrb::TEAL.current[Thread.current]
         global field
       end
 
@@ -722,5 +716,53 @@ module TEALrb
         Txna.application_args[index]
       end
     end
+
+    module MaybeOps
+      include Opcodes
+
+      def app_param_exists?(field, _app_id = nil)
+        app_params_get field
+        swap
+        pop
+      end
+
+      def app_param_value(field, _app_id = nil)
+        app_params_get field
+        pop
+      end
+
+      def asset_param_exists?(field, _asset_id = nil)
+        asset_params_get field
+        swap
+        pop
+      end
+
+      def asset_param_value(field, _asset_id = nil)
+        asset_params_get field
+        pop
+      end
+
+      def app_local_ex_exists?(_account = nil, _applicaiton = nil, _key = nil)
+        app_local_get_ex
+        swap
+        pop
+      end
+
+      def app_local_ex_value(_account = nil, _applicaiton = nil, _key = nil)
+        app_local_get_ex
+        pop
+      end
+
+      def app_global_ex_exists?(_account = nil, _applicaiton = nil, _key = nil)
+        app_global_get_ex
+        swap
+        pop
+      end
+
+      def app_global_ex_value(_account = nil, _applicaiton = nil, _key = nil)
+        app_global_get_ex
+        pop
+      end
+    end
   end
 end

data/lib/tealrb/opcodes.rb

@@ -42,620 +42,620 @@ module TEALrb
     }.freeze
 
     def acct_params_get(field, _account = nil)
-      TEALrb::TEAL.current[Thread.current] << "acct_params_get #{field}"
+      TEAL.instance << "acct_params_get #{field}"
     end
 
     def add(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << '+'
+      TEAL.instance << '+'
     end
 
     def addr(address)
-      TEALrb::TEAL.current[Thread.current] << "addr #{address}"
+      TEAL.instance << "addr #{address}"
     end
 
     def addw(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << 'addw'
+      TEAL.instance << 'addw'
     end
 
     def app_global_del(_key = nil)
-      TEALrb::TEAL.current[Thread.current] << 'app_global_del'
+      TEAL.instance << 'app_global_del'
     end
 
     def app_global_get(_key = nil)
-      TEALrb::TEAL.current[Thread.current] << 'app_global_get'
+      TEAL.instance << 'app_global_get'
     end
 
     def app_global_get_ex(_app = nil, _key = nil)
-      TEALrb::TEAL.current[Thread.current] << 'app_global_get_ex'
+      TEAL.instance << 'app_global_get_ex'
     end
 
     def app_global_put(_key = nil, _value = nil)
-      TEALrb::TEAL.current[Thread.current] << 'app_global_put'
+      TEAL.instance << 'app_global_put'
     end
 
     def app_local_del(_account = nil, _key = nil)
-      TEALrb::TEAL.current[Thread.current] << 'app_local_del'
+      TEAL.instance << 'app_local_del'
     end
 
     def app_local_get(_account = nil, _key = nil)
-      TEALrb::TEAL.current[Thread.current] << 'app_local_get'
+      TEAL.instance << 'app_local_get'
     end
 
     def app_local_get_ex(_account = nil, _application = nil, _key = nil)
-      TEALrb::TEAL.current[Thread.current] << 'app_local_get_ex'
+      TEAL.instance << 'app_local_get_ex'
     end
 
     def app_local_put(_account = nil, _key = nil, _value = nil)
-      TEALrb::TEAL.current[Thread.current] << 'app_local_put'
+      TEAL.instance << 'app_local_put'
     end
 
     def app_opted_in(_account = nil, _app = nil)
-      TEALrb::TEAL.current[Thread.current] << 'app_opted_in'
+      TEAL.instance << 'app_opted_in'
     end
 
     def app_params_get(field, _app_id = nil)
-      TEALrb::TEAL.current[Thread.current] << "app_params_get #{field}"
+      TEAL.instance << "app_params_get #{field}"
     end
 
     def approve
-      TEALrb::TEAL.current[Thread.current] << 'int 1'
-      TEALrb::TEAL.current[Thread.current] << 'return'
+      TEAL.instance << 'int 1'
+      TEAL.instance << 'return'
     end
 
     def arg(index)
-      TEALrb::TEAL.current[Thread.current] << "arg #{index}"
+      TEAL.instance << "arg #{index}"
     end
 
     def arg_0 # rubocop:disable Naming/VariableNumber
-      TEALrb::TEAL.current[Thread.current] << 'arg_0'
+      TEAL.instance << 'arg_0'
     end
 
     def arg_1 # rubocop:disable Naming/VariableNumber
-      TEALrb::TEAL.current[Thread.current] << 'arg_1'
+      TEAL.instance << 'arg_1'
     end
 
     def arg_2 # rubocop:disable Naming/VariableNumber
-      TEALrb::TEAL.current[Thread.current] << 'arg_2'
+      TEAL.instance << 'arg_2'
     end
 
     def arg_3 # rubocop:disable Naming/VariableNumber
-      TEALrb::TEAL.current[Thread.current] << 'arg_3'
+      TEAL.instance << 'arg_3'
     end
 
     def args(_index = nil)
-      TEALrb::TEAL.current[Thread.current] << 'args'
+      TEAL.instance << 'args'
     end
 
     def assert(_expr = nil)
-      TEALrb::TEAL.current[Thread.current] << 'assert'
+      TEAL.instance << 'assert'
     end
 
     def asset_holding_get(field, _account = nil, _asset = nil)
-      TEALrb::TEAL.current[Thread.current] << "asset_holding_get #{field}"
+      TEAL.instance << "asset_holding_get #{field}"
     end
 
     def asset_params_get(field, _asset = nil)
-      TEALrb::TEAL.current[Thread.current] << "asset_params_get #{field}"
+      TEAL.instance << "asset_params_get #{field}"
     end
 
     def b(target)
-      TEALrb::TEAL.current[Thread.current] << "#{__method__} #{target}"
+      TEAL.instance << "#{__method__} #{target}"
     end
 
     def base32(input)
-      TEALrb::TEAL.current[Thread.current] << "byte base32(#{input})"
+      TEAL.instance << "byte base32(#{input})"
     end
 
     def balance(_account = nil)
-      TEALrb::TEAL.current[Thread.current] << 'balance'
+      TEAL.instance << 'balance'
     end
 
     def big_endian_add(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << 'b+'
+      TEAL.instance << 'b+'
     end
 
     def big_endian_divide(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << 'b/'
+      TEAL.instance << 'b/'
     end
 
     def big_endian_equal(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << 'b=='
+      TEAL.instance << 'b=='
     end
 
     def big_endian_less(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << 'b<'
+      TEAL.instance << 'b<'
     end
 
     def big_endian_less_eq(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << 'b<='
+      TEAL.instance << 'b<='
     end
 
     def big_endian_modulo(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << 'b%'
+      TEAL.instance << 'b%'
     end
 
     def big_endian_more(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << 'b>'
+      TEAL.instance << 'b>'
     end
 
     def big_endian_more_eq(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << 'b>='
+      TEAL.instance << 'b>='
     end
 
     def big_endian_multiply(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << 'b*'
+      TEAL.instance << 'b*'
     end
 
     def big_endian_not_equal(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << 'b!='
+      TEAL.instance << 'b!='
     end
 
     def big_endian_subtract(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << 'b-'
+      TEAL.instance << 'b-'
     end
 
     def bitlen(_input = nil)
-      TEALrb::TEAL.current[Thread.current] << 'bitlen'
+      TEAL.instance << 'bitlen'
     end
 
     def bitwise_and(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << '&'
+      TEAL.instance << '&'
     end
 
     def bitwise_byte_invert(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << 'b~'
+      TEAL.instance << 'b~'
     end
 
     def bitwise_invert(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << '~'
+      TEAL.instance << '~'
     end
 
     def bitwise_or(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << '|'
+      TEAL.instance << '|'
     end
 
     def bitwise_xor(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << '^'
+      TEAL.instance << '^'
     end
 
     def bnz(target)
-      TEALrb::TEAL.current[Thread.current] << "#{__method__} #{target}"
+      TEAL.instance << "#{__method__} #{target}"
     end
 
     def bsqrt(_big_endian_uint = nil)
-      TEALrb::TEAL.current[Thread.current] << 'bsqrt'
+      TEAL.instance << 'bsqrt'
     end
 
     def btoi(_bytes = nil)
-      TEALrb::TEAL.current[Thread.current] << 'btoi'
+      TEAL.instance << 'btoi'
     end
 
     def byte(string)
-      TEALrb::TEAL.current[Thread.current] << "byte \"#{string}\""
+      TEAL.instance << "byte \"#{string}\""
     end
 
     def bytec(index)
-      TEALrb::TEAL.current[Thread.current] << "bytec #{index}"
+      TEAL.instance << "bytec #{index}"
     end
 
     def bytec_0 # rubocop:disable Naming/VariableNumber
-      TEALrb::TEAL.current[Thread.current] << 'bytec_0'
+      TEAL.instance << 'bytec_0'
     end
 
     def bytec_1 # rubocop:disable Naming/VariableNumber
-      TEALrb::TEAL.current[Thread.current] << 'bytec_1'
+      TEAL.instance << 'bytec_1'
     end
 
     def bytec_2 # rubocop:disable Naming/VariableNumber
-      TEALrb::TEAL.current[Thread.current] << 'bytec_2'
+      TEAL.instance << 'bytec_2'
     end
 
     def bytec_3 # rubocop:disable Naming/VariableNumber
-      TEALrb::TEAL.current[Thread.current] << 'bytec_3'
+      TEAL.instance << 'bytec_3'
     end
 
     def bytecblock(*bytes)
-      TEALrb::TEAL.current[Thread.current] << "bytecblock #{bytes.join(' ')}"
+      TEAL.instance << "bytecblock #{bytes.join(' ')}"
     end
 
     def bz(target)
-      TEALrb::TEAL.current[Thread.current] << "#{__method__} #{target}"
+      TEAL.instance << "#{__method__} #{target}"
     end
 
     def bzero(_length = nil)
-      TEALrb::TEAL.current[Thread.current] << 'bzero'
+      TEAL.instance << 'bzero'
     end
 
     def callsub(name, *_args)
-      TEALrb::TEAL.current[Thread.current] << "callsub #{name}"
+      TEAL.instance << "callsub #{name}"
     end
 
     def concat(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << 'concat'
+      TEAL.instance << 'concat'
     end
 
     def cover(count)
-      TEALrb::TEAL.current[Thread.current] << "cover #{count}"
+      TEAL.instance << "cover #{count}"
     end
 
     def dig(index)
-      TEALrb::TEAL.current[Thread.current] << "dig #{index}"
+      TEAL.instance << "dig #{index}"
     end
 
     def divide(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << '/'
+      TEAL.instance << '/'
     end
 
     def divmodw(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << 'divmodw'
+      TEAL.instance << 'divmodw'
     end
 
     def divw(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << 'divw'
+      TEAL.instance << 'divw'
     end
 
     def dup(_expr = nil)
-      TEALrb::TEAL.current[Thread.current] << 'dup'
+      TEAL.instance << 'dup'
     end
 
     def dup2(_expr_a = nil, _expr_b = nil)
-      TEALrb::TEAL.current[Thread.current] << 'dup2'
+      TEAL.instance << 'dup2'
     end
 
     def ecdsa_pk_decompress(index, _input = nil)
-      TEALrb::TEAL.current[Thread.current] << "ecdsa_pk_decompress #{index}"
+      TEAL.instance << "ecdsa_pk_decompress #{index}"
     end
 
     def ecdsa_pk_recover(index, _input = nil)
-      TEALrb::TEAL.current[Thread.current] << "ecdsa_pk_recover #{index}"
+      TEAL.instance << "ecdsa_pk_recover #{index}"
     end
 
     def ecdsa_verify(index, _input = nil)
-      TEALrb::TEAL.current[Thread.current] << "ecdsa_verify #{index}"
+      TEAL.instance << "ecdsa_verify #{index}"
     end
 
     def ed25519verify(_input = nil)
-      TEALrb::TEAL.current[Thread.current] << 'ed25519verify'
+      TEAL.instance << 'ed25519verify'
     end
 
     def equal(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << '=='
+      TEAL.instance << '=='
     end
 
     def err
-      TEALrb::TEAL.current[Thread.current] << 'err'
+      TEAL.instance << 'err'
     end
 
     def exp(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << 'exp'
+      TEAL.instance << 'exp'
     end
 
     def expw(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << 'expw'
+      TEAL.instance << 'expw'
     end
 
     def extract(start, length, _byte_array = nil)
-      TEALrb::TEAL.current[Thread.current] << "extract #{start} #{length}"
+      TEAL.instance << "extract #{start} #{length}"
     end
 
     def extract3(_byte_array = nil, _start = nil, _exclusive_end = nil)
-      TEALrb::TEAL.current[Thread.current] << 'extract3'
+      TEAL.instance << 'extract3'
     end
 
     def extract_uint16(_byte_array = nil, _start = nil)
-      TEALrb::TEAL.current[Thread.current] << 'extract_uint16'
+      TEAL.instance << 'extract_uint16'
     end
 
     def extract_uint32(_byte_array = nil, _start = nil)
-      TEALrb::TEAL.current[Thread.current] << 'extract_uint32'
+      TEAL.instance << 'extract_uint32'
     end
 
     def extract_uint64(_byte_array = nil, _start = nil)
-      TEALrb::TEAL.current[Thread.current] << 'extract_uint64'
+      TEAL.instance << 'extract_uint64'
     end
 
     def gaid(transaction_index)
-      TEALrb::TEAL.current[Thread.current] << "gaid #{transaction_index}"
+      TEAL.instance << "gaid #{transaction_index}"
     end
 
     def gaids(_transaction = nil)
-      TEALrb::TEAL.current[Thread.current] << 'gaids'
+      TEAL.instance << 'gaids'
     end
 
     def getbit(_input = nil, _bit_index = nil)
-      TEALrb::TEAL.current[Thread.current] << 'getbit'
+      TEAL.instance << 'getbit'
     end
 
     def getbyte(_input = nil, _byte_index = nil)
-      TEALrb::TEAL.current[Thread.current] << 'getbyte'
+      TEAL.instance << 'getbyte'
     end
 
     def gitxn(transaction_index, field)
-      TEALrb::TEAL.current[Thread.current] << "gitxn #{transaction_index} #{field}"
+      TEAL.instance << "gitxn #{transaction_index} #{field}"
     end
 
     def gitxna(transaction_index, field, index)
-      TEALrb::TEAL.current[Thread.current] << "gitxna #{transaction_index} #{field} #{index}"
+      TEAL.instance << "gitxna #{transaction_index} #{field} #{index}"
     end
 
     def gitxnas(transaction_index, field, _index = nil)
-      TEALrb::TEAL.current[Thread.current] << "gitxnas #{transaction_index} #{field}"
+      TEAL.instance << "gitxnas #{transaction_index} #{field}"
     end
 
     def gload(transaction_index, index)
-      TEALrb::TEAL.current[Thread.current] << "gload #{transaction_index} #{index}"
+      TEAL.instance << "gload #{transaction_index} #{index}"
     end
 
     def gloads(index, _transaction_index = nil)
-      TEALrb::TEAL.current[Thread.current] << "gloads #{index}"
+      TEAL.instance << "gloads #{index}"
     end
 
     def gloadss(_transaction = nil, _index = nil)
-      TEALrb::TEAL.current[Thread.current] << 'gloadss'
+      TEAL.instance << 'gloadss'
     end
 
     def global(field)
-      TEALrb::TEAL.current[Thread.current] << "global #{field}"
+      TEAL.instance << "global #{field}"
     end
 
     def greater(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << '>'
+      TEAL.instance << '>'
     end
 
     def greater_eq(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << '>='
+      TEAL.instance << '>='
     end
 
     def gtxn(index, field)
-      TEALrb::TEAL.current[Thread.current] << "gtxn #{index} #{field}"
+      TEAL.instance << "gtxn #{index} #{field}"
     end
 
     def gtxna(transaction_index, field, index)
-      TEALrb::TEAL.current[Thread.current] << "gtxna #{transaction_index} #{field} #{index}"
+      TEAL.instance << "gtxna #{transaction_index} #{field} #{index}"
     end
 
     def gtxns(field, _transaction_index = nil)
-      TEALrb::TEAL.current[Thread.current] << "gtxns #{field}"
+      TEAL.instance << "gtxns #{field}"
     end
 
     def gtxnsa(field, index, _transaction_index = nil)
-      TEALrb::TEAL.current[Thread.current] << "gtxnsa #{field} #{index}"
+      TEAL.instance << "gtxnsa #{field} #{index}"
     end
 
     def gtxnas(transaction_index, field, _index = nil)
-      TEALrb::TEAL.current[Thread.current] << "gtxnas #{transaction_index} #{field}"
+      TEAL.instance << "gtxnas #{transaction_index} #{field}"
     end
 
     def gtxnsas(field, _transaction_index = nil, _index = nil)
-      TEALrb::TEAL.current[Thread.current] << "gtxnsas #{field}"
+      TEAL.instance << "gtxnsas #{field}"
     end
 
     def int(integer)
-      TEALrb::TEAL.current[Thread.current] << "int #{integer}"
+      TEAL.instance << "int #{integer}"
     end
 
     def intc(index)
-      TEALrb::TEAL.current[Thread.current] << "intc #{index}"
+      TEAL.instance << "intc #{index}"
     end
 
     def intc_0 # rubocop:disable Naming/VariableNumber
-      TEALrb::TEAL.current[Thread.current] << 'intc_0'
+      TEAL.instance << 'intc_0'
     end
 
     def intc_1 # rubocop:disable Naming/VariableNumber
-      TEALrb::TEAL.current[Thread.current] << 'intc_1'
+      TEAL.instance << 'intc_1'
     end
 
     def intc_2 # rubocop:disable Naming/VariableNumber
-      TEALrb::TEAL.current[Thread.current] << 'intc_2'
+      TEAL.instance << 'intc_2'
     end
 
     def intc_3 # rubocop:disable Naming/VariableNumber
-      TEALrb::TEAL.current[Thread.current] << 'intc_3'
+      TEAL.instance << 'intc_3'
     end
 
     def intcblock(*ints)
-      TEALrb::TEAL.current[Thread.current] << "intcblock #{ints.join(' ')}"
+      TEAL.instance << "intcblock #{ints.join(' ')}"
     end
 
     def itob(_bytes = nil)
-      TEALrb::TEAL.current[Thread.current] << 'itob'
+      TEAL.instance << 'itob'
     end
 
     def itxn_begin
-      TEALrb::TEAL.current[Thread.current] << 'itxn_begin'
+      TEAL.instance << 'itxn_begin'
     end
 
     def itxn_field(field, _value = nil)
-      TEALrb::TEAL.current[Thread.current] << "itxn_field #{field}"
+      TEAL.instance << "itxn_field #{field}"
     end
 
     def itxn_next
-      TEALrb::TEAL.current[Thread.current] << 'itxn_next'
+      TEAL.instance << 'itxn_next'
     end
 
     def itxn_submit
-      TEALrb::TEAL.current[Thread.current] << 'itxn_submit'
+      TEAL.instance << 'itxn_submit'
     end
 
     def itxna(field, index)
-      TEALrb::TEAL.current[Thread.current] << "itxna #{field} #{index}"
+      TEAL.instance << "itxna #{field} #{index}"
     end
 
     def itxnas(field, _index = nil)
-      TEALrb::TEAL.current[Thread.current] << "itxnas #{field}"
+      TEAL.instance << "itxnas #{field}"
     end
 
     def keccak256(_input = nil)
-      TEALrb::TEAL.current[Thread.current] << 'keccak256'
+      TEAL.instance << 'keccak256'
     end
 
     def label(label_name)
-      TEALrb::TEAL.current[Thread.current] << "#{label_name}:"
+      TEAL.instance << "#{label_name}:"
     end
 
     def len(_input = nil)
-      TEALrb::TEAL.current[Thread.current] << 'len'
+      TEAL.instance << 'len'
     end
 
     def less(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << '<'
+      TEAL.instance << '<'
     end
 
     def less_eq(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << '<='
+      TEAL.instance << '<='
     end
 
     def load(index)
-      TEALrb::TEAL.current[Thread.current] << "load #{index}"
+      TEAL.instance << "load #{index}"
     end
 
     def loads(_index = nil)
-      TEALrb::TEAL.current[Thread.current] << 'loads'
+      TEAL.instance << 'loads'
     end
 
     def log(_byte_array = nil)
-      TEALrb::TEAL.current[Thread.current] << 'log'
+      TEAL.instance << 'log'
     end
 
     def method_signature(signature)
-      TEALrb::TEAL.current[Thread.current] << %(method "#{signature}")
+      TEAL.instance << %(method "#{signature}")
     end
 
     def min_balance(_account = nil)
-      TEALrb::TEAL.current[Thread.current] << 'min_balance'
+      TEAL.instance << 'min_balance'
     end
 
     def modulo(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << '%'
+      TEAL.instance << '%'
     end
 
     def multiply(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << '*'
+      TEAL.instance << '*'
     end
 
     def mulw(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << 'mulw'
+      TEAL.instance << 'mulw'
     end
 
     def zero?(_expr = nil)
-      TEALrb::TEAL.current[Thread.current] << '!'
+      TEAL.instance << '!'
     end
 
     def not_equal(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << '!='
+      TEAL.instance << '!='
     end
 
     def padded_bitwise_and(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << 'b&'
+      TEAL.instance << 'b&'
     end
 
     def padded_bitwise_or(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << 'b|'
+      TEAL.instance << 'b|'
     end
 
     def padded_bitwise_xor(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << 'b^'
+      TEAL.instance << 'b^'
     end
 
     def pop(_expr = nil)
-      TEALrb::TEAL.current[Thread.current] << 'pop'
+      TEAL.instance << 'pop'
     end
 
     def pushbytes(string)
-      TEALrb::TEAL.current[Thread.current] << "pushbytes \"#{string}\""
+      TEAL.instance << "pushbytes \"#{string}\""
     end
 
     def pushint(integer)
-      TEALrb::TEAL.current[Thread.current] << "pushint #{integer}"
+      TEAL.instance << "pushint #{integer}"
     end
 
     def retsub
-      TEALrb::TEAL.current[Thread.current] << 'retsub'
+      TEAL.instance << 'retsub'
     end
 
     def select(_expr_a = nil, _expr_b = nil, _expr_c = nil)
-      TEALrb::TEAL.current[Thread.current] << 'select'
+      TEAL.instance << 'select'
     end
 
     def setbit(_input = nil, _bit_index = nil, _value = nil)
-      TEALrb::TEAL.current[Thread.current] << 'setbit'
+      TEAL.instance << 'setbit'
     end
 
     def setbyte(_byte_array = nil, _byte_index = nil, _value = nil)
-      TEALrb::TEAL.current[Thread.current] << 'setbyte'
+      TEAL.instance << 'setbyte'
     end
 
     def sha256(_input = nil)
-      TEALrb::TEAL.current[Thread.current] << 'sha256'
+      TEAL.instance << 'sha256'
     end
 
     def sha512_256(_input = nil) # rubocop:disable Naming/VariableNumber
-      TEALrb::TEAL.current[Thread.current] << 'sha512_256'
+      TEAL.instance << 'sha512_256'
     end
 
     def shl(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << 'shl'
+      TEAL.instance << 'shl'
     end
 
     def shr(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << 'shr'
+      TEAL.instance << 'shr'
     end
 
     def sqrt(_integer = nil)
-      TEALrb::TEAL.current[Thread.current] << 'sqrt'
+      TEAL.instance << 'sqrt'
     end
 
     def store(index, _value = nil)
-      TEALrb::TEAL.current[Thread.current] << "store #{index}"
+      TEAL.instance << "store #{index}"
     end
 
     def stores(_index = nil, _value = nil)
-      TEALrb::TEAL.current[Thread.current] << 'stores'
+      TEAL.instance << 'stores'
     end
 
     def substring(start, exclusive_end, _byte_array = nil)
-      TEALrb::TEAL.current[Thread.current] << "substring #{start} #{exclusive_end}"
+      TEAL.instance << "substring #{start} #{exclusive_end}"
     end
 
     def substring3(_byte_array = nil, _start = nil, _exclusive_end = nil)
-      TEALrb::TEAL.current[Thread.current] << 'substring3'
+      TEAL.instance << 'substring3'
     end
 
     def subtract(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << '-'
+      TEAL.instance << '-'
     end
 
     def swap(_expr_a = nil, _expr_b = nil)
-      TEALrb::TEAL.current[Thread.current] << 'swap'
+      TEAL.instance << 'swap'
     end
 
     def teal_return(_expr = nil)
-      TEALrb::TEAL.current[Thread.current] << 'return'
+      TEAL.instance << 'return'
     end
 
     def txn(field)
-      TEALrb::TEAL.current[Thread.current] << "txn #{field}"
+      TEAL.instance << "txn #{field}"
     end
 
     def txna(field, index)
-      TEALrb::TEAL.current[Thread.current] << "txna #{field} #{index}"
+      TEAL.instance << "txna #{field} #{index}"
     end
 
     def txnas(field, _index = nil)
-      TEALrb::TEAL.current[Thread.current] << "txnas #{field}"
+      TEAL.instance << "txnas #{field}"
     end
 
     def uncover(count)
-      TEALrb::TEAL.current[Thread.current] << "uncover #{count}"
+      TEAL.instance << "uncover #{count}"
     end
 
     def boolean_and(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << '&&'
+      TEAL.instance << '&&'
     end
 
     def boolean_or(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << '||'
+      TEAL.instance << '||'
     end
   end
 end

data/lib/tealrb/rewriters.rb

@@ -66,8 +66,7 @@ module TEALrb
       end
 
       def on_ivar(node)
-        insert_after(node.loc.name, '.call') unless ['@teal', '@teal_methods', '@subroutines',
-                                                     '@scratch'].include? node.source
+        insert_after(node.loc.name, '.call') unless ['@teal_methods', '@subroutines', '@scratch'].include? node.source
         super
       end
     end
@@ -83,7 +82,7 @@ module TEALrb
 
     class OpRewriter < Rewriter
       def initialize
-        @skips = 0
+        @skips = []
         super
       end
 
@@ -110,44 +109,62 @@ module TEALrb
 
       OPCODE_METHODS = TEALrb::Opcodes.instance_methods.freeze
 
-      def on_const(node)
-        @skips = 1 if %w[Txna Gtxn AppArgs].include? node.loc.name.source
-        super
-      end
-
-      def on_ivar(node)
-        @skips = 2 if node.source == '@teal_methods'
-        @skips = 1 if node.source == '@scratch'
-      end
-
       def on_send(node)
-        meth_name = node.loc.selector.source.to_sym
+        meth_name = node.children[1]
 
         if OPCODE_METHODS.include? meth_name
           if meth_name[/(byte|int)cblock/]
-            @skips = node.children.size - 2
+            @skips += node.children[2..]
           else
             params = TEALrb::Opcodes.instance_method(meth_name).parameters
-            @skips = params.count { |param| param[0] == :req }
+            req_params = params.count { |param| param[0] == :req }
+            @skips += node.children[2..(1 + req_params.size)] unless req_params.zero?
           end
-        elsif %i[comment placeholder rb].include? meth_name
-          @skips = node.children.last.children.size
+        elsif %i[comment placeholder rb].include?(meth_name) ||
+              (%i[[] []=].include?(meth_name) &&
+                  (
+                    %i[@scratch @teal_methods Gtxn
+                       AppArgs].include?(node.children[0].children.last) ||
+                    node.children[0].children.first&.children&.last == :Txna
+                  ))
+
+          @skips << node.children[2]
+        elsif node.children.first&.children&.last == :@scratch && meth_name[/=$/]
+          nil
+        elsif %i[@scratch Gtxn].include? node.children.first&.children&.last
+          @skips << node.children.last
         end
+
         super
       end
 
       def on_int(node)
-        wrap(node.source_range, 'int(', ')') if (@skips -= 1).negative?
+        if @skips.include? node
+          @skips.delete(node)
+        else
+          wrap(node.source_range, 'int(', ')')
+        end
+
         super
       end
 
       def on_str(node)
-        wrap(node.source_range, 'byte(', ')') if (@skips -= 1).negative?
+        if @skips.include? node
+          @skips.delete(node)
+        else
+          wrap(node.source_range, 'byte(', ')')
+        end
+
         super
       end
 
       def on_sym(node)
-        wrap(node.source_range, 'label(', ')') if node.source_range.source[/^:/] && (@skips -= 1).negative?
+        if @skips.include? node
+          @skips.delete(node)
+        elsif node.source_range.source[/^:/]
+          wrap(node.source_range, 'label(', ')')
+        end
+
         super
       end
     end
@@ -156,7 +173,7 @@ module TEALrb
       def on_if(node)
         case node.loc.keyword.source
         when 'if'
-          replace(node.loc.keyword, 'IfBlock.new(@teal, ')
+          replace(node.loc.keyword, 'IfBlock.new(')
         when 'elsif'
           replace(node.loc.keyword, 'end.elsif(')
         end

data/lib/tealrb/scratch.rb

@@ -2,14 +2,13 @@
 
 module TEALrb
   class Scratch
-    def initialize(teal)
-      @teal = teal
+    def initialize
       @open_slots = (0..256).to_a
       @named_slots = {}
     end
 
     def [](key)
-      @teal << "load #{@named_slots[key]} // #{key}"
+      TEAL.instance << "load #{@named_slots[key]} // #{key}"
     end
 
     def []=(key, _value)
@@ -17,7 +16,7 @@ module TEALrb
     end
 
     def store(key)
-      @teal << "store #{@named_slots[key] ||= @open_slots.shift} // #{key}"
+      TEAL.instance << "store #{@named_slots[key] ||= @open_slots.shift} // #{key}"
     end
 
     def delete(key)
@@ -34,5 +33,21 @@ module TEALrb
     def unreserve(slot)
       @open_slots << slot
     end
+
+    def respond_to_missing?
+      !!(meth[/=$/] || @named_slots.key?(meth.to_s))
+    end
+
+    def method_missing(meth, *args, &block)
+      super unless block.nil?
+
+      if meth[/=$/]
+        store(meth.to_s.chomp('='))
+      elsif @named_slots.key?(meth.to_s)
+        self[meth.to_s]
+      else
+        super
+      end
+    end
   end
 end

data/lib/tealrb.rb

@@ -16,13 +16,18 @@ require_relative 'tealrb/cmd_line/teal2tealrb'
 module TEALrb
   class TEAL < Array
     class << self
-      attr_accessor :current
-    end
+      attr_writer :instance
+
+      def instance
+        raise 'TEALrb does not support multi-threading' if Thread.current != Thread.main
 
-    @current = {}
+        @instance
+      end
+    end
 
-    def set_as_current
-      self.class.current[Thread.current] = self
+    def initialize(teal_array)
+      self.class.instance = self
+      super
     end
 
     def teal

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tealrb
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Joe Polny
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-05-27 00:00:00.000000000 Z
+date: 2022-07-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: method_source