rbs2ts 1.0.0.pre.alpha.4 → 1.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 19a2022b86feae5d562c59457ea77de37ef3a94f6c32b2b148f278610cf3e64d
-  data.tar.gz: 94639b023729996b58f6a7ed7f59cbfe58b7738e820ea70fb100ad9e7f079690
+  metadata.gz: bce4c75f9675cfc5cccfac710ac9547d5c33153e76e5ef1299bc1f1808612f05
+  data.tar.gz: c550da676c3b095c07438e7085f176f8fa150d061ba10803ea9bb0805917067d
 SHA512:
-  metadata.gz: 918d61866526af2f4d258fe349c5617dfc65d799086fff57fb32bfa2e6104713fed20558dd2e451ba09c860316aedb07f6637a5cdd650babfa477a61ca490f78
-  data.tar.gz: 5fd2d4d0c042f9a226f89dd8867d48464ccae74333afb5f77e437eb793f5db85ae2882c49ac600f2abd8caf7f8e948d9cefa23b28ce30b4b8cb54dc8d663321d
+  metadata.gz: 34aa7a35786539f22d03e58e25902fdc4a074bd76bc1b54d05dc2a52b9bb1864e27f4a2a1eea916fb6e06e62a1371b9490b40e117f119dd70bb31b250c010769
+  data.tar.gz: 76ba38c3514225a63ecd288d17891281c5b1b90a1edea1e8a655b3d91357a62eb6b8c02fa100c93e4505d5819ac8526dfd0d2fc87e9f9eec7dae65633eb15518

data/README.md

@@ -1,6 +1,6 @@
 # Rbs2ts
 
-Convert RBS to TypeScript type definition.
+A RubyGem that converts Ruby RBS to TypeScript definitions.
 
 ## Installation
 
@@ -33,8 +33,8 @@ type StringLiteral = 'abc'
 type TrueLiteral = true
 type FalseLiteral = false
 
-type UnionType = String & Integer & Bool
-type IntersectionType = String | Integer | Bool
+type IntersectionType = String & Integer & Bool
+type UnionType = String | Integer | Bool
 
 type ArrayType = Array[String]
 
@@ -52,6 +52,7 @@ type RecordType = {
 }
 
 class Klass
+  @val: String
   attr_accessor a: String
   attr_reader b: Integer
   attr_writer c: Bool
@@ -64,8 +65,44 @@ class Klass
     }?
   }
 
-  def to_s: () -> String
-  def tuple: () -> [{ s: String, f: Float }?]
+  def to_tuple: () -> [{ s: String, f: Float }?]
+  def required_positional: (String) -> void
+  def required_positional_name: (String str) -> void
+  def optional_positional: (?String) -> void
+  def optional_positional_name: (?String? str) -> void
+  def rest_positional: (*String) -> void
+  def rest_positional_name: (*String str) -> void
+  def rest_positional_with_trailing: (*String, Integer) -> void
+  def rest_positional_name_with_trailing: (*String str, Integer trailing) -> void
+  def required_keyword: (str: String) -> void
+  def optional_keyword: (?str: String?) -> void
+  def rest_keywords: (**String) -> void
+  def rest_keywords_name: (**String rest) -> void
+
+  def all_arguments: (
+    String required_positional,
+    ?Integer? optional_positional,
+    *String rest_positionals_s,
+    Integer trailing_positional_s,
+    required_keyword: String,
+    ?optional_keyword: Integer?,
+    **String rest_keywords
+  ) -> [{ s: String, f: Float }?]
+end
+
+module Module
+  @val: String
+  type AliasType = String
+
+  def func: (String, Integer) -> { str: String, int: Integer }
+
+  class NestedClass
+    attr_accessor a: AliasType
+  end
+end
+
+interface _Interface
+  def func: (String, Integer) -> { str: String, int: Integer }
 end
 ```
 
@@ -96,9 +133,9 @@ export type TrueLiteral = true;
 
 export type FalseLiteral = false;
 
-export type UnionType = string & number & boolean;
+export type IntersectionType = string & number & boolean;
 
-export type IntersectionType = string | number | boolean;
+export type UnionType = string | number | boolean;
 
 export type ArrayType = string[];
 
@@ -116,34 +153,56 @@ export type RecordType = {
   } | null | undefined;
 };
 
-export namespace Klass {
-  export type a = string;
-  export type b = number;
-  export type r = {
+export declare class Klass {
+  val: string;
+  a: string;
+  readonly b: number;
+  c: boolean;
+  readonly r: {
     d: string;
     e: {
       f: string;
       g: string | null | undefined;
     } | null | undefined;
   };
-  export type toSReturnType = string;
-  export type tupleReturnType = [({
+  toTuple(): [({
+    s: string;
+    f: number;
+  } | null | undefined)];
+  requiredPositional(arg1: string): void;
+  requiredPositionalName(str: string): void;
+  optionalPositional(arg1?: string): void;
+  optionalPositionalName(str?: string | null | undefined): void;
+  restPositional(...arg1: string[]): void;
+  restPositionalName(...str: string[]): void;
+  restPositionalWithTrailing(arg1: string[], arg2: number): void;
+  restPositionalNameWithTrailing(str: string[], trailing: number): void;
+  requiredKeyword(arg1: { str: string }): void;
+  optionalKeyword(arg1: { str?: string | null | undefined }): void;
+  restKeywords(arg1: { [key: string]: unknown; }): void;
+  restKeywordsName(arg1: { [key: string]: unknown; }): void;
+  allArguments(requiredPositional: string, optionalPositional?: number | null | undefined, restPositionalsS?: string[], trailingPositionalS?: number, arg1?: { requiredKeyword: string, optionalKeyword?: number | null | undefined, [key: string]: unknown; }): [({
     s: string;
     f: number;
   } | null | undefined)];
 };
-```
-
----
 
-## ToDo
+export namespace Module {
+  export declare let val: string;
+  export type AliasType = string;
+  export declare function func(arg1: string, arg2: number): {
+    str: string;
+    int: number;
+  };
+  export declare class NestedClass {
+    a: AliasType;
+  };
+};
 
-- [x] Literal type
-- [ ] Interface type
-- [x] Literal type
-- [x] Tuple Type
-- [x] Base Types
-- [x] Method Type (Argument Types and Return Types)
-- [x] Class declaration
-- [ ] Module declaration
-- [ ] Interface declaration
+export interface Interface {
+  func(arg1: string, arg2: number): {
+    str: string;
+    int: number;
+  };
+};
+```

data/lib/rbs2ts/converter.rb

@@ -3,5 +3,7 @@ end
 
 require 'case_transform'
 
+require 'rbs2ts/converter/helper'
 require 'rbs2ts/converter/declarations'
 require 'rbs2ts/converter/types'
+require 'rbs2ts/converter/members'

data/lib/rbs2ts/converter/declarations.rb

@@ -11,6 +11,10 @@ module Rbs2ts
             case d
             when ::RBS::AST::Declarations::Class then
               Converter::Declarations::Class.new(d).to_ts
+            when ::RBS::AST::Declarations::Module then
+              Converter::Declarations::Module.new(d).to_ts
+            when ::RBS::AST::Declarations::Interface then
+              Converter::Declarations::Interface.new(d).to_ts
             when ::RBS::AST::Declarations::Alias then
               Converter::Declarations::Alias.new(d).to_ts
             end
@@ -31,34 +35,23 @@ module Rbs2ts
         end
 
         def name
-          declaration.name.to_s.gsub(/:/, '')
+          declaration.name.name.to_s
         end
     
         private
     
         attr_reader :declaration
       end
-  
-      class Class < Base
-        INDENT = '  '
-        @@nest = 0
 
+      class Class < Base
         def to_ts
-          @@nest = @@nest + 1
-
           members_ts = declaration.members.map {|member|
-            ts = member_to_ts(member)
-            ts
-              .split("\n")
-              .map {|t| "#{INDENT * @@nest}#{t}" }
-              .join("\n")
+            member_to_ts(member)
           }.reject(&:empty?).join("\n")
 
-          @@nest = @@nest - 1
-
           <<~TS
-            export namespace #{name} {
-            #{members_ts}
+            export declare class #{Converter::Helper.convert_name(name)} {
+            #{Helper.indent(members_ts)}
             };
           TS
           .chomp
@@ -66,10 +59,16 @@ module Rbs2ts
 
         def member_to_ts(member)
           case member
-          when ::RBS::AST::Members::AttrReader, ::RBS::AST::Members::AttrAccessor then
-            "export type #{CaseTransform.camel_lower(member.name)} = #{Converter::Types::Resolver.to_ts(member.type)};"
+          when ::RBS::AST::Members::InstanceVariable then
+            Converter::Members::InstanceVariable.new(member).to_ts
+          when ::RBS::AST::Members::AttrReader then
+            Converter::Members::AttrReader.new(member).to_ts
+          when ::RBS::AST::Members::AttrWriter then
+            Converter::Members::AttrWriter.new(member).to_ts
+          when ::RBS::AST::Members::AttrAccessor then
+            Converter::Members::AttrAccessor.new(member).to_ts
           when ::RBS::AST::Members::MethodDefinition
-            "export type #{CaseTransform.camel_lower(member.name)}ReturnType = #{Converter::Types::Resolver.to_ts(member.types.first.type.return_type)};"
+            Converter::Members::MethodDefinition.new(member).to_ts
           else
             ''
           end
@@ -77,14 +76,68 @@ module Rbs2ts
       end
   
       class Module < Base
+        def to_ts
+          members_ts = declaration.members.map {|member|
+            member_to_ts(member)
+          }.reject(&:empty?).join("\n")
+
+          <<~TS
+            export namespace #{Converter::Helper.convert_name(name)} {
+            #{Helper.indent(members_ts)}
+            };
+          TS
+          .chomp
+        end
+
+        def member_to_ts(member)
+          case member
+          when ::RBS::AST::Declarations::Class then
+            Converter::Declarations::Class.new(member).to_ts
+          when ::RBS::AST::Declarations::Module then
+            Converter::Declarations::Module.new(member).to_ts
+          when ::RBS::AST::Declarations::Interface then
+            Converter::Declarations::Interface.new(member).to_ts
+          when ::RBS::AST::Declarations::Alias then
+            Converter::Declarations::Alias.new(member).to_ts
+          when ::RBS::AST::Members::InstanceVariable
+            ts = Converter::Members::InstanceVariable.new(member).to_ts
+            "export declare let #{ts}"
+          when ::RBS::AST::Members::MethodDefinition
+            ts = Converter::Members::MethodDefinition.new(member).to_ts
+            "export declare function #{ts}"
+          else
+            ''
+          end
+        end
       end
   
       class Interface < Base
+        def to_ts
+          members_ts = declaration.members.map {|member|
+            member_to_ts(member)
+          }.reject(&:empty?).join("\n")
+
+          <<~TS
+            export interface #{Converter::Helper.convert_name(name.gsub(/_/, ''))} {
+            #{Helper.indent(members_ts)}
+            };
+          TS
+          .chomp
+        end
+
+        def member_to_ts(member)
+          case member
+          when ::RBS::AST::Members::MethodDefinition
+            Converter::Members::MethodDefinition.new(member).to_ts
+          else
+            ''
+          end
+        end
       end
   
       class Alias < Base
         def to_ts
-          "export type #{name} = #{Converter::Types::Resolver.to_ts(declaration.type)};"
+          "export type #{Converter::Helper.convert_name(name)} = #{Converter::Types::Resolver.to_ts(declaration.type)};"
         end
       end
   

data/lib/rbs2ts/converter/helper.rb

@@ -0,0 +1,38 @@
+module Rbs2ts
+  module Converter
+    module Helper
+      class << self
+        INDENT = '  '
+
+        def indent(text, level = 1)
+          text
+            .split("\n")
+            .map {|t| "#{INDENT * level}#{t}" }
+            .join("\n")
+        end
+
+        TS_RESERVED_WORDS = %w(
+          any as boolean break case catch class const constructor continue debugger declare
+          default delete do else enum export extends false finally for from function get if
+          implements import in instanceof interface let module new null number of package
+          private protected public require return set static string super switch symbol
+          this throw true try type typeof var void while with yield
+        )
+
+        def convert_name(org_name)
+          name = org_name.to_s.gsub(/[:@]/, '')
+
+          unless name =~ /^[A-Z]/
+            name = CaseTransform.camel_lower(name)
+          end
+
+          if TS_RESERVED_WORDS.include?(name)
+            "#{name}Type"
+          else
+            name
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rbs2ts/converter/members.rb

@@ -0,0 +1,146 @@
+module Rbs2ts
+  module Converter
+    module Members
+      class Base
+        def initialize(member)
+          @member = member
+        end
+    
+        def to_ts
+          ''
+        end
+
+        def name
+          Converter::Helper.convert_name(member.name)
+        end
+    
+        private
+    
+        attr_reader :member
+      end
+
+      class InstanceVariable < Base
+        def to_ts
+          "#{name}: #{Converter::Types::Resolver.to_ts(member.type)};"
+        end
+      end
+
+      class AttrReader < Base
+        def to_ts
+          "readonly #{name}: #{Converter::Types::Resolver.to_ts(member.type)};"
+        end
+      end
+
+      class AttrWriter < Base
+        def to_ts
+          "#{name}: #{Converter::Types::Resolver.to_ts(member.type)};"
+        end
+      end
+
+      class AttrAccessor < Base
+        def to_ts
+          "#{name}: #{Converter::Types::Resolver.to_ts(member.type)};"
+        end
+      end
+
+      class MethodDefinition < Base
+        def initialize(member)
+          super
+          @args_count = 0
+        end
+
+        def to_ts
+          "#{name}(#{args_to_ts}): #{return_type_to_ts};"
+        end
+
+        def args_to_ts
+          [
+            *required_positional_to_ts,
+            *optional_positional_to_ts,
+            *rest_positionals_to_ts,
+            *trailing_positionals_to_ts,
+            *keyword_args_to_ts
+          ].join(", ")
+        end
+
+        def arg_name(arg)
+          name = arg.name.nil? ? next_default_arg_name : arg.name.to_s
+          CaseTransform.camel_lower(name)
+        end
+
+        def next_default_arg_name
+          @args_count = @args_count + 1
+          "arg#{@args_count.to_s}"
+        end
+
+        def required_positional_to_ts
+          method_type.required_positionals.map {|arg|
+            "#{arg_name(arg)}: #{Converter::Types::Resolver.to_ts(arg.type)}"
+          }
+        end
+
+        def optional_positional_to_ts
+          method_type.optional_positionals.map {|arg|
+            "#{arg_name(arg)}?: #{Converter::Types::Resolver.to_ts(arg.type)}"
+          }
+        end
+
+        def rest_positionals_to_ts
+          arg = method_type.rest_positionals
+          
+          return [] if arg.nil?
+
+          has_rest_after_arguments ?
+            ["#{arg_name(arg)}#{optional_ts_code}: #{Converter::Types::Resolver.to_ts(arg.type)}[]"] :
+            ["...#{arg_name(arg)}#{optional_ts_code}: #{Converter::Types::Resolver.to_ts(arg.type)}[]"]
+        end
+
+        def trailing_positionals_to_ts
+          method_type.trailing_positionals.map {|arg|
+            "#{arg_name(arg)}#{optional_ts_code}: #{Converter::Types::Resolver.to_ts(arg.type)}"
+          }
+        end
+
+        def keyword_args_to_ts
+          required_keywords_ts = method_type.required_keywords.map {|key, value|
+            "#{CaseTransform.camel_lower(key.to_s)}: #{Converter::Types::Resolver.to_ts(value.type)}"
+          }
+          optional_keywords_ts = method_type.optional_keywords.map {|key, value|
+            "#{CaseTransform.camel_lower(key.to_s)}?: #{Converter::Types::Resolver.to_ts(value.type)}"
+          }
+          rest_keywords_ts = method_type.rest_keywords.nil? ? [] : ["[key: string]: unknown;"]
+
+          ts_array = [
+            *required_keywords_ts,
+            *optional_keywords_ts,
+            *rest_keywords_ts
+          ]
+
+          return [] if ts_array.empty?
+
+          ts = ts_array.join(', ')
+
+          ["#{next_default_arg_name}#{optional_ts_code}: { #{ts} }"]
+        end
+
+        def method_type
+          member.types.first.type
+        end
+
+        def return_type_to_ts
+          Converter::Types::Resolver.to_ts(method_type.return_type)
+        end
+
+        def optional_ts_code
+          method_type.optional_positionals.present? ? '?' : ''
+        end
+
+        def has_rest_after_arguments
+          method_type.trailing_positionals.present? || 
+          method_type.required_keywords.present? ||
+          method_type.optional_keywords.present?
+        end
+      end
+    end
+  end
+end

data/lib/rbs2ts/converter/types.rb

@@ -46,27 +46,19 @@ module Rbs2ts
       end
 
       class Record < ConverterBase
-        INDENT = '  '
-        @@nest = 0
-
         def to_ts
-          @@nest = @@nest + 1
-
-          indent = INDENT * @@nest
           field_lines = type.fields.map { |name, type|
-            "#{indent}#{CaseTransform.camel_lower(name.to_s)}: #{Types::Resolver.to_ts(type)};"
+            "#{Converter::Helper.convert_name(name)}: #{Types::Resolver.to_ts(type)};"
           }
 
-          @@nest = @@nest - 1
-
           return '{}' if field_lines.empty?
 
           field_ts = field_lines.join("\n")
 
           ts = <<~CODE
           {
-          #{field_ts}
-          #{INDENT * @@nest}}
+          #{Helper.indent(field_ts)}
+          }
           CODE
     
           ts.chomp
@@ -144,7 +136,7 @@ module Rbs2ts
           when 'Bool' then
             Types::Bool.new(type).to_ts
           else
-            type.name.to_s.gsub(/:/, '')
+            Converter::Helper.convert_name(type.name.name)
           end
         end
       end

data/lib/rbs2ts/version.rb

@@ -1,3 +1,3 @@
 module Rbs2ts
-  VERSION = "1.0.0-alpha.4"
+  VERSION = "1.3.1"
 end

data/rbs2ts.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |spec|
   spec.authors       = ["mugi-uno"]
   spec.email         = ["mugi.uno@gmail.com"]
 
-  spec.summary       = "Convert rbs to typescript"
+  spec.summary       = "A RubyGem that converts Ruby RBS to TypeScript definitions."
   spec.homepage      = "https://github.com/mugi-uno/rbs2ts"
   spec.license       = "MIT"
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rbs2ts
 version: !ruby/object:Gem::Version
-  version: 1.0.0.pre.alpha.4
+  version: 1.3.1
 platform: ruby
 authors:
 - mugi-uno
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-01-17 00:00:00.000000000 Z
+date: 2021-01-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rbs
@@ -118,6 +118,8 @@ files:
 - lib/rbs2ts/cli.rb
 - lib/rbs2ts/converter.rb
 - lib/rbs2ts/converter/declarations.rb
+- lib/rbs2ts/converter/helper.rb
+- lib/rbs2ts/converter/members.rb
 - lib/rbs2ts/converter/types.rb
 - lib/rbs2ts/version.rb
 - rbs2ts.gemspec
@@ -136,12 +138,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubygems_version: 3.1.4
 signing_key:
 specification_version: 4
-summary: Convert rbs to typescript
+summary: A RubyGem that converts Ruby RBS to TypeScript definitions.
 test_files: []