ton-client-ruby 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0321af077acd0b4c971b583f6448bbb0c9633abfd72be60a9a442bd595f74bc2
-  data.tar.gz: 3e2bca8f73c5dd23dc5c60be5655d2f777d58a5870d1176d3633ef69d0eb52b4
+  metadata.gz: 7d9f09aaabae6ed86f5adc9a77082f2c94ad685437fb7457e490253086ca80b5
+  data.tar.gz: 6e2e1b73de3671c362fbb0ebdb919e9fdc7b94fabe8302b46fc3159ba42100af
 SHA512:
-  metadata.gz: 242a9a7821f494ef4165d3c3b25d680c194b9be860a766fab753d44b05332a1c5a14e5674347a0af31f52af34e751a980352070000c1cadd67b4949e88faba11
-  data.tar.gz: fdca0400955e2d5010bde1ed0ca3b938f43a9198c315e8bed2cca7d9518bca57ee02f1447576a5dd52b6a1c03b26601fbd641d2c3d3b099ae68beec2ffacef1c
+  metadata.gz: 621cc074093d4de7603aa1135dc597681aaf72337f42bab12bb9e3692f58462f7eb7696e04b029945abda6c85dbc584bc8d72804d89882d1d98966a69a139acd
+  data.tar.gz: 9cf4d820e210ab28a1a64dbf6474b954de1b35166c692321b648464b3258b88a033678382a222237814a93b206c0f5ce07734399e0bd72774ff5a1f207a856be

data/bin/ton-client-ruby

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+
+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__) + '/..'
+
+if ARGV[0] == 'update'
+  if !ARGV[1]
+    puts ''
+    puts ''
+    p "PLEASE DOWNLOAD api.json from https://github.com/tonlabs/TON-SDK/blob/master/tools/api.json and pass as second parameter."
+    p "Example: ton-client-ruby update ./api.json" 
+    puts ''
+    return
+  end
+  api_json_path = ARGV[1]
+  json = ''
+  if File.exists?(api_json_path)
+    json = File.read(api_json_path)
+  else
+    p "Current directory: #{Dir.pwd}. File #{api_json_path} is not exist"
+    exit 0
+  end
+  converter = ApiConverter.new(json)
+  types = converter.convert
+  generator = CodeGenerator.new(types, GEM_DIR)
+  generator.generate_self_code
+elsif ARGV[0] == 'update' && ARGV[1] == nil
+  p 'soon from github'
+elsif ARGV[0] == 'setup'
+  raise "\nPLEASE INSTALL RUST TO YOUR SYSTEM. \nTry this command: \ncurl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh" if `which rustc`.strip.empty?
+  unless Dir.exist?("#{GEM_DIR}/TON-SDK")
+    system("cd #{GEM_DIR} && git clone https://github.com/tonlabs/TON-SDK ./TON-SDK")
+  end
+  system("cd #{GEM_DIR}/TON-SDK && git pull --ff-only")
+  system("cd #{GEM_DIR}/TON-SDK && cargo update")
+  system("cd #{GEM_DIR}/TON-SDK && cargo build --release")
+  puts ''
+  puts "PATH TO YOR DYNAMIC LIBRARY IS: #{GEM_DIR}/TON-SDK/target/release/libton_client.dylib"
+  puts ''
+end

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