ton-client-ruby 1.0.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d7dfd053a1c976028bc40dfe2cf9bb4750beee2688428ae7b8cfc9ff7e3c4d8d
-  data.tar.gz: 651588ea67891811a9a847dda130c5cc2c6d1aac770213254b16c47ce4384238
+  metadata.gz: b17d66a87de3133d8f5a6f84d76615156c7bf9648da6825584a269c33cad85bb
+  data.tar.gz: dab93ec7b176f1d70478ee2bc95b0a77a47104586a49bc0acc43032ab87649ff
 SHA512:
-  metadata.gz: 30e93f4c4d28c0b0d8af0766a5d9f632b1a3263ff63ac0edb312bb552b28404f5a2c5129fc418b9a18c440e7a6e6be8e18886c8377d83b28d58157d9052572e1
-  data.tar.gz: 88ea3e6773d2d005a48ffdc7cb1ca4992f4a0955606814ceaed33c9f391b4842fac02d8043c35496fd69feb9eea70c34080b6c0b4f6b73eddf10122818c4dc46
+  metadata.gz: 26cd4d5b9531449e9922b2cdf4ec9222bd2101a15ee27740a68865492cebc8c08f799ea40b1f8ea35d116792c062ef6cbd7923e49784d8628163429e612f7a0c
+  data.tar.gz: deff9cde16ae317c0783bf1ddac5c7c65fb6c58c982adcaf601391d872eb95022351ecec7196b856327efe9de4c5bd0e0c07d6fa1b169a96c4eb28d63b8d14bf

data/bin/ton-client-ruby

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 
-require File.dirname(__FILE__) + '/../code_generator/api_converter.rb'
-require File.dirname(__FILE__) + '/../code_generator/code_generator.rb'
+require File.dirname(__FILE__) + '/../lib/code_generator/api_converter.rb'
+require File.dirname(__FILE__) + '/../lib/code_generator/code_generator.rb'
 
 GEM_DIR = File.dirname(__FILE__) + '/..'
 

data/lib/code_generator/api_converter.rb

@@ -0,0 +1,399 @@
+require 'json'
+require 'byebug'
+require File.dirname(__FILE__) + '/helpers.rb'
+
+
+
+class ApiConverter
+  include InstanceHelpers
+
+  attr_reader :api_hash
+  
+  def initialize(api_json)
+    @api_hash = JSON.parse(api_json)
+  end
+
+  def convert
+    ruby_types = ApiRubyTypes.new(version: api_hash['version'], modules: [])
+
+    (api_hash['modules'] || []).each do |mod|
+      new_mod = convert_module(mod)
+      ruby_types.modules << new_mod
+      ruby_types.all_types.merge!(new_mod.types_hash)
+    end
+
+    ruby_types
+  end
+
+  private
+
+  def convert_module(mod)
+    new_module = Module.new(name: mod['name'], alias: [], functions: [], enums: [], types: [], summary: mod['summary'], description: mod['description'])
+    (mod['types'] || []).each do |type|
+      if type['type'] == 'EnumOfTypes'
+        new_enum, new_struct = convert_fucking_enum_of_types(type)
+        new_module.enums << new_enum
+        new_module.types << new_struct
+        new_module.types_hash[new_enum.name] = new_enum
+        new_module.types_hash[new_struct.name] = new_struct
+      elsif type['type'] == 'EnumOfConsts'
+        new_type = convertEnumOfConsts(type)
+        new_module.enums << new_type
+        new_module.types_hash[new_type.name] = new_type
+      elsif type['type'] == 'Struct'
+        new_type = convertStruct(type)
+        new_module.types << new_type
+        new_module.types_hash[new_type.name] = new_type
+      elsif type['type'] == 'Number'
+        new_type = convertTypeAlias(type)
+        new_module.alias << new_type
+        new_module.types_hash[new_type.name] = new_type
+      else
+        raise "Unkown NEW TYPE for module #{type['name']} \"types\": #{type['types']}"
+      end
+    end
+
+    # /// FUNCTIONS
+    (mod['functions'] || []).each do |function|
+        result = ""
+        if function['result']['type'] == "Generic"
+            ref_type = function['result']['generic_args'].first&.send(:[], 'type') || ""
+            if ref_type == "Ref"
+                ref_name = function['result']['generic_args'].first&.send(:[], 'ref_name') || ""
+                if ref_name[/^(.+)\.(.+)$/]
+                    mod = $1
+                    type = $2
+                    result = "#{lib_prefix}#{type}"
+                else
+                    raise "Bad function result ref_name: #{ref_name}, function name: #{function['name']}, result: #{function['result']}"
+                end
+            elsif ref_type == "None"
+              result = "Void"
+            end
+        else
+          raise "New function result type !"
+        end
+
+        # /// function
+        newFunction = StructFunction.new(name: checkFunctionName(function['name']), arguments: [], result: result, summary: function['summary'], description: function['description'])
+        # /// FUNCTION PARAMETERS
+        paramsCount = 0
+        (function['params'] || []).each do |parameter|
+            if parameter['name'] == "params"
+                paramsCount += 1
+                if parameter['type'] == "Ref"
+                    ref_name = parameter['ref_name'] || ""
+                    if ref_name[/^(.+)\.(.+)$/]
+                        mod = $1
+                        type = $2
+                        newFunction.arguments << FunctionArgument.new(name: "payload", type: "#{lib_prefix}#{type}")
+                    else
+                      raise "Bad function params ref_name: #{ref_name}, function name: #{function['name']}, result: #{function['result']}"
+                    end
+                else
+                  raise "NEW CASE! New parameter type: #{parameter['type']}"
+                end
+            end
+            raise "NEW CASE ! More then one parameter for functions !" if paramsCount > 1
+        end
+
+        new_module.functions << newFunction
+    end
+
+    new_module
+  end
+
+  def convertTypeAlias(from)
+    TypeAlias.new(name: "#{lib_prefix}#{from['name']}", type: generateType(from))
+  end
+
+  def convertStruct(from)
+    result = TypeStruct.new(name: "#{lib_prefix}#{from['name']}", parents: [], fields: [], functions: [])
+    (from['struct_fields'] || []).each do |field|
+      if isValidPropertyName(field['name'])
+        type = generateType(field)
+        if ( (from['name'] || "")[/Params/] || (field['name'] || "")[/input/]) && type[/Value/]
+          type = "Value"
+        elsif (field['name'] || "")[/^dictionary$/]
+          type = "#{lib_prefix}MnemonicDictionary"
+        elsif type[/Abi<Optional>/]
+          type = "Value<Optional>"
+        elsif type[/Abi/]
+          type = "Value"
+        end
+        property = StructField.new(name: checkPropertyName(field['name']), type: type, summary: field['summary'], description: field['description'])
+        result.fields << property
+      end
+    end
+
+    result
+  end
+
+  private def checkPropertyName(name)
+      result = ""
+      raise "Property Name is nil" unless name
+      
+      case name
+      when "public"
+          result = "public"
+      else
+          result = name
+      end
+
+      return result
+  end
+
+  private def checkFunctionName(name)
+    result = ""
+    raise "Property Name is nil" unless name
+    case name
+    when "init"
+      result = "init"
+    else
+      result = name
+    end
+
+    return result
+  end
+
+  private def isValidPropertyName(name)
+    !(name || " ")[/\s/]
+  end
+
+  def convertEnumOfConsts(from)
+      result = TypeEnum.new(name: "#{lib_prefix}#{from['name']}", parents: [], cases: [], summary: from['summary'], description: from['description'])
+      (from['enum_consts'] || []).each do |enumConst|
+          caseName = enumConst['name']
+          caseValue = enumConst['value']
+          result.cases << EnumCase.new(name: caseName, value: caseValue, summary: enumConst['summary'], description: enumConst['description'])
+      end
+
+      return result
+  end
+
+  def convert_fucking_enum_of_types(enum)
+    result = [
+      TypeEnum.new(name: generate_enum_name(enum['name']), parents: [], cases: []),
+      TypeStruct.new(name: generate_struct_name(enum['name']), parents: [], fields: [], functions: [], summary: enum['summary'], description: enum['description'])
+    ]
+    properties_name_set = Set.new
+    properties = []
+    (enum['enum_types'] || []).each do |enum_type|
+      result[0].cases << EnumCase.new(name: enum_type['name'], value: enum_type['name'])
+      (enum_type['struct_fields'] || []).each do |field|
+        if !properties_name_set.include?(field['name'])
+          properties << field
+        end
+        properties_name_set << field['name']
+      end
+    end
+
+    result[1].fields << StructField.new(name: "type", type: generate_enum_name(enum['name']))
+    properties.each do |property|
+      type = generateType(property)
+      if property['name'][/^dictionary$/]
+        type = "#{lib_prefix}MnemonicDictionary"
+      end
+      result[1].fields << StructField.new(name: property['name'], type: type, summary: property['summary'], description: property['description'])
+    end
+    result
+  end
+
+  private def generateSimpleType(type)
+    tempType = ""
+
+    if type['type'] == "Ref"
+      if type['ref_name'] == "Value" || type['ref_name'] == "API"
+        tempType = "Value"
+      else
+        return type['optional'] ? "#{generateRefType(type['ref_name'] || "nil")}<Optional>" : generateRefType(type['ref_name'] || "nil")
+      end
+    else
+      tempType = type['type']
+    end
+    tempType = "#{tempType}<Optional>" if type['optional']
+
+    tempType
+  end
+
+  private def generateRefType(type)
+    result = ""
+
+    if type[/(.+)\.(.+)/]
+      mod = $1
+      typeName = $2
+      result = "#{lib_prefix}#{typeName}"
+    else
+      result = "#{lib_prefix}#{type}"
+    end
+
+    result
+  end
+
+  private def generateType(type)
+    if type['type'] == "Optional" && type['optional_inner']
+      type['optional'] = true
+      type['optional_inner']['optional'] = true
+      if type['optional_inner']['type'] == "Optional"
+        return generateType(type['optional_inner'])
+      else
+        return generateSimpleType(type['optional_inner'])
+      end
+    else 
+      return generateSimpleType(type)
+    end
+  end
+
+  private def generate_enum_name(name)
+    "#{lib_prefix}#{name}#{lib_enum_postfix}"
+  end
+
+  private def generate_struct_name(name)
+    "#{lib_prefix}#{name}"
+  end
+end
+
+
+class ApiRubyTypes
+  attr_accessor :version
+  attr_accessor :modules
+  attr_accessor :all_types
+
+  def initialize(params)
+    @all_types = {}
+    params.each do |k, v|
+      if self.respond_to?(k.to_sym)
+        instance_variable_set("@#{k}".to_sym, v)
+      end
+    end
+  end
+end
+
+class Module
+  attr_accessor :name
+  attr_accessor :summary
+  attr_accessor :description
+  attr_accessor :alias
+  attr_accessor :enums
+  attr_accessor :types
+  attr_accessor :types_hash
+  attr_accessor :functions
+  attr_accessor :summary
+  attr_accessor :description
+
+  def initialize(params)
+    @types_hash = {}
+    params.each do |k, v|
+      if self.respond_to?(k.to_sym)
+        instance_variable_set("@#{k}".to_sym, v)
+      end
+    end
+  end
+end
+
+class TypeAlias
+  attr_accessor :name
+  attr_accessor :type
+  attr_accessor :summary
+  attr_accessor :description
+
+  def initialize(params)
+    params.each do |k, v|
+      if self.respond_to?(k.to_sym)
+        instance_variable_set("@#{k}".to_sym, v)
+      end
+    end
+  end
+end
+
+class TypeEnum
+  attr_accessor :name
+  attr_accessor :parents
+  attr_accessor :cases
+  attr_accessor :summary
+  attr_accessor :description
+
+  def initialize(params)
+    params.each do |k, v|
+      if self.respond_to?(k.to_sym)
+        instance_variable_set("@#{k}".to_sym, v)
+      end
+    end
+  end
+end
+
+class EnumCase
+  attr_accessor :name
+  attr_accessor :value
+  attr_accessor :summary
+  attr_accessor :description
+
+  def initialize(params)
+    params.each do |k, v|
+      if self.respond_to?(k)
+        instance_variable_set("@#{k}".to_sym, v)
+      end
+    end
+  end
+end
+
+class TypeStruct
+  attr_accessor :name
+  attr_accessor :parents
+  attr_accessor :fields
+  attr_accessor :functions
+  attr_accessor :summary
+  attr_accessor :description
+
+  def initialize(params)
+    params.each do |k, v|
+      if self.respond_to?(k.to_sym)
+        instance_variable_set("@#{k}".to_sym, v)
+      end
+    end
+  end
+end
+
+class StructField
+  attr_accessor :name
+  attr_accessor :type
+  attr_accessor :summary
+  attr_accessor :description
+
+  def initialize(params)
+    params.each do |k, v|
+      if self.respond_to?(k.to_sym)
+        instance_variable_set("@#{k}".to_sym, v)
+      end
+    end
+  end
+end
+
+class StructFunction
+  attr_accessor :name
+  attr_accessor :arguments
+  attr_accessor :result
+  attr_accessor :summary
+  attr_accessor :description
+
+  def initialize(params)
+    params.each do |k, v|
+      if self.respond_to?(k.to_sym)
+        instance_variable_set("@#{k}".to_sym, v)
+      end
+    end
+  end
+end
+
+class FunctionArgument
+  attr_accessor :name
+  attr_accessor :type
+
+  def initialize(params)
+    params.each do |k, v|
+      if self.respond_to?(k.to_sym)
+        instance_variable_set("@#{k}".to_sym, v)
+      end
+    end
+  end
+end

data/lib/code_generator/code_generator.rb

@@ -0,0 +1,318 @@
+require 'byebug'
+require 'json'
+require File.dirname(__FILE__) + '/helpers.rb'
+
+class CodeGenerator
+  include InstanceHelpers
+
+  attr_accessor :types
+  attr_accessor :root_dir
+
+  TAB = "  "
+
+  def initialize(types, root_dir)
+    @types = types
+    @root_dir = root_dir
+  end
+
+  def generate_self_code
+    generateModules(types)
+    generateReadme(types)
+  end
+
+  private
+
+  def generateModules(types)
+    types.modules.each do |mod|
+      modulesFolder = root_dir + "/lib/ton-client-ruby/Client"
+      moduleFilePath = "#{modulesFolder}/#{mod.name.capitalize}.rb"
+      newModuleContent = ""
+      if mod.name == "client"
+          newModuleContent = generateClientModule(mod, types.modules)
+      else
+          newModuleContent = generateModule(mod)
+      end
+      if File.exists?(moduleFilePath)
+          File.delete(moduleFilePath)
+      end
+      File.open(moduleFilePath, 'w+') { |f| f.write(newModuleContent) }
+    end
+    
+    p 'generate_self_code ok'
+  end
+
+  def generateReadme(types)
+    readmePath = root_dir + "/README.md"
+    content = %{
+# Ruby Client for Free TON SDK
+
+[![GEM](https://img.shields.io/badge/ruby-gem-green)]()
+
+## Install
+
+Install gem
+```bash
+gem install ton-client-ruby
+```
+
+Install TON-SDK
+```bash
+ton-client-ruby setup
+```
+
+### Manual build FreeTON SDK
+0. Install Rust to your OS
+1. git clone https://github.com/tonlabs/TON-SDK
+2. cd ./TON-SDK
+3. cargo update
+4. cargo build --release
+
+## Usage
+
+```ruby
+# For MAcOS
+TonClient.configure { |config| config.ffi_lib(./TON-SDK/target/release/libton_client.dylib) }
+# For Linux
+# TonClient.configure { |config| config.ffi_lib(./TON-SDK/target/release/libton_client.so) }
+
+client = TonClient.create(config: {network: {server_address: "net.ton.dev"}})
+
+# All methods are asynchronous
+
+# example: call method for Crypto module
+payload = {composite: '17ED48941A08F981'}
+client.crypto.factorize(payload) do |response|
+  p response.result['factors']
+end
+
+# e.g. ...
+```\n\n
+}
+    content << "## All Modules, methods and types\n\n"
+
+    # types
+    content << "<details>\n#{TAB}<summary>Types</summary>\n\n"
+    
+    content << "#{customTypes()}\n"
+
+    types.modules.each do |mod|
+      (mod.enums || []).each do |type|
+        content << checkComment(type.summary, 0) if type.summary
+        content << checkComment(type.description, 0) if type.description
+        content << "\n- #### #{type.name}\n"
+        (type.cases || []).each do |enum_case|
+          content << "#{checkComment(enum_case.summary, 1).gsub(/#/, '')}" if enum_case.summary
+          content << "#{checkComment(enum_case.description, 1).gsub(/#/, '')}" if enum_case.description
+          content << "#{TAB}- case #{enum_case.name} = #{enum_case.value}\n\n"
+        end
+      end
+
+      (mod.types || []).each do |type|
+        content << checkComment(type.summary, 0) if type.summary
+        content << checkComment(type.description, 0) if type.description
+        content << "\n- #### #{type.name}\n"
+        (type.fields || []).each do |field|
+          content << "#{checkComment(field.summary, 1).gsub(/#/, '')}\n" if field.summary
+          content << "#{checkComment(field.description, 1).gsub(/#/, '')}\n" if field.description
+          content << "#{TAB}- #{field.name}: #{field.type}\n\n"
+        end
+      end
+    end
+    content << "</details>\n\n"
+
+    # methods
+    types.modules.each do |mod|
+      content << "<details>\n#{TAB}<summary>#{mod.name&.upcase}</summary>\n\n"
+      (mod.functions || []).each do |function|
+        content << "```ruby\n"
+        content << checkComment(function.summary, 2) if function.summary
+        content << checkComment(function.description, 2) if function.description
+        content << "\n#{TAB}#{TAB}def #{function.name}"
+        if function.arguments.empty?
+          content << "(&block)\n"
+        else
+          content << "(payload, &block)\n"
+        end
+        content << getFunctionComment(function, types)
+        content << "```\n"
+      end
+      content << "</details>\n\n"
+    end
+
+    content << %{
+\n## Tests
+
+1. create __.env.test__ file inside root directory of this library with variables   
+
+example for NodeSE   
+```
+spec_ffi=./TON-SDK/target/release/libton_client.dylib
+server_address=http://localhost:80
+giver_abi_name=GiverNodeSE
+giver_amount=10000000000
+```
+2. Run tests: inside folder of this library execute this commands      
+**rspec spec/binding.rb**   
+**rspec spec/client.rb**  
+**rspec spec/context.rb**  
+**rspec spec/abi.rb**   
+**rspec spec/boc.rb**   
+**rspec spec/crypto.rb**   
+**rspec spec/net.rb**   
+**rspec spec/processing.rb**   
+**rspec spec/tvm.rb**   
+**rspec spec/utils.rb**
+}
+    content = checkContent(content)    
+    if File.exists?(readmePath)
+        File.delete(readmePath)
+    end
+    File.open(readmePath, 'w+') { |f| f.write(content) }
+  end
+
+  private def checkContent(content)
+    content.gsub!(/^([\s]+)# RESPONSE/, "\n\\1# RESPONSE")
+    content.gsub(/<Optional>/i, '&lt;Optional&gt;')
+  end
+
+  def customTypes
+    content = %{
+- #### #{lib_prefix}MnemonicDictionary
+#{TAB}- case TON = 0
+#{TAB}- case ENGLISH = 1
+#{TAB}- case CHINESE_SIMPLIFIED = 2
+#{TAB}- case CHINESE_TRADITIONAL = 3
+#{TAB}- case FRENCH = 4
+#{TAB}- case ITALIAN = 5
+#{TAB}- case JAPANESE = 6
+#{TAB}- case KOREAN = 7
+#{TAB}- case SPANISH = 8
+}
+  content
+  end
+
+  private def checkComment(string, tabs = 1)
+      replacedString = "\n"
+      tab = ""
+      tabs.times do |i|
+          tab << TAB
+      end
+      comment = "#"
+      replacedString << "#{tab}#{comment} "
+      symbolsWithSpace = "\\.|\\:|\\!|\\?|\\;"
+      regxp = /([^#{symbolsWithSpace}])\n/
+      result = string
+      result.gsub!(/\n+/, "\n")
+      result.gsub!(/ \n/, "\n#{comment} ")
+      result.gsub!(/(#{symbolsWithSpace})\s*\n/, "\\1#{replacedString}")
+      result.gsub!(regxp, "\\1")
+      "#{tab}# #{result}"
+  end
+
+  private def generateClientModule(mod, modules)
+    content = "module TonClient\n\n#{TAB}class #{mod.name.capitalize}\n#{TAB}#{TAB}include CommonInstanceHelpers\n\n"
+    content << "#{TAB}#{TAB}attr_reader :core, :context\n"
+    content << "#{TAB}#{TAB}private_accessor "
+    modules.each_with_index do |m, i|
+      next if m.name.downcase == 'client'
+      content << ((modules.size - 1) == i ? ":_#{m.name}\n" : ":_#{m.name}, ")
+    end
+    content << "#{TAB}#{TAB}MODULE = self.to_s.downcase.gsub(/^(.+::|)(\\w+)$/, '\\2').freeze\n\n"
+    content << "#{TAB}#{TAB}def initialize(context: Context.new, core: TonClient::TonBinding)\n"
+    content << "#{TAB}#{TAB}#{TAB}@context = context\n"
+    content << "#{TAB}#{TAB}#{TAB}@core = core\n#{TAB}#{TAB}end\n\n"
+    content << "#{TAB}#{TAB}def destroy_context\n"
+    content << "#{TAB}#{TAB}#{TAB}core.tc_destroy_context(context.id)\n#{TAB}#{TAB}end\n\n"
+    modules.each_with_index do |m, i|
+      next if m.name.downcase == 'client'
+      content << "#{TAB}#{TAB}def #{m.name}\n"
+      content << "#{TAB}#{TAB}#{TAB}_#{m.name} ||= #{m.name.capitalize}.new(context: context)\n"
+      content << "#{TAB}#{TAB}end\n\n"
+    end
+
+    mod.functions.each do |func|
+      content << gen_function(func, types)
+    end
+
+    content << "#{TAB}end\n"
+    content << "end\n\n"
+
+    content
+  end
+
+  private def generateModule(mod)
+    content = "module TonClient\n\n#{TAB}class #{mod.name.capitalize}\n#{TAB}#{TAB}include CommonInstanceHelpers\n\n"
+    content << "#{TAB}#{TAB}attr_reader :core, :context\n"
+    content << "#{TAB}#{TAB}MODULE = self.to_s.downcase.gsub(/^(.+::|)(\\w+)$/, '\\2').freeze\n\n"
+    content << "#{TAB}#{TAB}def initialize(context: Context.new, core: TonClient::TonBinding)\n"
+    content << "#{TAB}#{TAB}#{TAB}@context = context\n"
+    content << "#{TAB}#{TAB}#{TAB}@core = core\n"
+    content << "#{TAB}#{TAB}end\n\n"
+
+    mod.functions.each do |func|
+      content << gen_function(func, types)
+    end
+
+    content << "#{TAB}end\n"
+    content << "end\n\n"
+
+    content
+  end
+
+  private def gen_function(function, types)
+    content = getFunctionComment(function, types)
+    content << "#{TAB}#{TAB}def #{function.name}"
+    if function.arguments.empty?
+      content << "(&block)\n"
+      content << "#{TAB}#{TAB}#{TAB}core.requestLibrary(context: context.id, method_name: full_method_name(MODULE, __method__.to_s), payload: {}, &block)\n"
+    else
+      content << "(payload, &block)\n"
+      content << "#{TAB}#{TAB}#{TAB}core.requestLibrary(context: context.id, method_name: full_method_name(MODULE, __method__.to_s), payload: payload, &block)\n"
+    end
+    content << "#{TAB}#{TAB}end\n\n"
+
+    content
+  end
+
+  def getFunctionComment(function, types)
+    content = ''
+    if argument = function.arguments.first
+      content << "#{TAB}#{TAB}# INPUT: #{argument.type}\n"
+      if types.all_types[argument.type].respond_to?(:fields)
+        types.all_types[argument.type].fields.each do |arg|
+          content << "#{TAB}#{TAB}# #{arg.name}: #{arg.type} - "
+          content << "#{TAB}#{TAB}# #{checkComment(arg.summary, 2)}" if arg.summary
+          content << "#{TAB}#{TAB}# #{checkComment(arg.description, 2)}" if arg.description
+          content << "\n"
+        end
+      elsif types.all_types[argument.type].respond_to?(:cases)
+      end
+    end
+    
+    if types.all_types[function.result]
+      content << "#{TAB}#{TAB}# RESPONSE: #{function.result}\n"
+      if types.all_types[function.result].respond_to?(:fields)
+        types.all_types[function.result].fields.each do |arg|
+          content << "#{TAB}#{TAB}# #{arg.name}: #{arg.type} - "
+          content << "#{TAB}#{TAB}# #{checkComment(arg.summary, 2)}" if arg.summary
+          content << "#{TAB}#{TAB}# #{checkComment(arg.description, 2)}" if arg.description
+          content << "\n"
+        end
+      elsif types.all_types[function.result].respond_to?(:cases)
+      end
+    end
+
+    content
+  end
+end
+
+
+
+
+
+
+
+
+
+
+

data/lib/code_generator/helpers.rb

@@ -0,0 +1,13 @@
+require 'json'
+require 'byebug'
+
+module InstanceHelpers
+  
+  def lib_prefix 
+    '' 
+  end
+
+  def lib_enum_postfix
+    ''
+  end
+end

data/lib/ton-client-ruby/version.rb

@@ -1,3 +1,3 @@
 module TonClient
-  VERSION = "1.0.1"
+  VERSION = "1.0.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ton-client-ruby
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2
 platform: ruby
 authors:
 - nerzh
@@ -103,6 +103,9 @@ extensions: []
 extra_rdoc_files: []
 files:
 - bin/ton-client-ruby
+- lib/code_generator/api_converter.rb
+- lib/code_generator/code_generator.rb
+- lib/code_generator/helpers.rb
 - lib/ton-client-ruby.rb
 - lib/ton-client-ruby/Binding/binding.rb
 - lib/ton-client-ruby/Binding/struct.rb