rbs2ts 1.0.0.pre.alpha.3 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eb1b221a5b895071e46b77dcf36fd1df3e789b0af6f91cb78adbfef7aa633c1c
-  data.tar.gz: 1a452ee8992929e84d0cfde11006e1b9918a4dbfb5cd597506523d6491199c7f
+  metadata.gz: 4743b73de60833c61821721455c9c6f23cb7e6f9616179df62af629ad9ceb99c
+  data.tar.gz: '097d7ccc401a1c0684c433b4fc11279409ff75d6bf99e2b2340953f456d40986'
 SHA512:
-  metadata.gz: c6242c6655d8ab4d43267c4fb4d7a99471d27047b5b1ea04025aada0066f272b61ffa353a06bcd238a11890d3a65ff5bf32cb6471543a00d5036b734e5b84cba
-  data.tar.gz: 9a9d8d78d4eadd2cd9999063d841d878259f5bc52ccfbb0ea02b4691ef0a3133d8c8ab4cb954767925d0564e0c930697b1cd0017a4d476704a8f08515933bfd1
+  metadata.gz: d0b28b0b98c1cb73b247f397da3b64cc0c9c2d9bebd71f54c5a377fbbb9301b5ffd2c337810be8c61e2d71eca5df613707a3b266144816e8dcce31d26c55a095
+  data.tar.gz: 5ee48310c33f8ede00253b84037ccfab31a7cbd4cc1262aa041bab223a431b991b6792875d327724f71503c84a81ba1460fe9ad05130f13802a8cdded6cf71f6

data/.prettierignore

@@ -0,0 +1 @@
+README.md

data/.vscode/launch.json

@@ -10,7 +10,7 @@
       "request": "launch",
       "program": "${workspaceRoot}/exe/rbs2ts",
       "useBundler": true,
-      "args": ["convert", "spec/sample_rbs/test.rbs"]
+      "args": ["convert", "spec/fixtures/test.rbs"]
     }
   ]
 }

data/README.md

@@ -1,8 +1,6 @@
 # Rbs2ts
 
-[![mugi_uno](https://circleci.com/<VCS>/<ORG_NAME>/<PROJECT_NAME>.svg?style=svg)](LINK)
-
-Convert RBS to TypeScript type definition.
+A RubyGem that converts Ruby RBS to TypeScript definitions.
 
 ## Installation
 
@@ -16,16 +14,195 @@ gem install rbs2ts
 rbs2ts convert type.rbs
 ```
 
----
+## Example
+
+from RBS
+
+```
+type TypeofInteger = Integer
+type TypeofFloat = Float
+type TypeofNumeric = Numeric
+type TypeofString = String
+type TypeofBool = Bool
+type TypeofVoid = void
+type TypeofUntyped = untyped
+type TypeofNil = nil
+
+type IntegerLiteral = 123
+type StringLiteral = 'abc'
+type TrueLiteral = true
+type FalseLiteral = false
+
+type IntersectionType = String & Integer & Bool
+type UnionType = String | Integer | Bool
+
+type ArrayType = Array[String]
+
+type TupleType = [ ]
+type TupleEmptyType = [String, Integer]
+
+type OptionalType = String?
+
+type RecordType = {
+  s: String,
+  next: {
+    i: Integer,
+    f: Float
+  }?
+}
+
+class Klass
+  @val: String
+  attr_accessor a: String
+  attr_reader b: Integer
+  attr_writer c: Bool
+
+  attr_reader r: {
+    d: String,
+    e: {
+      f: String,
+      g: String?
+    }?
+  }
+
+  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
+```
+
+to TypeScript
+
+```typescript
+export type TypeofInteger = number;
 
-## ToDo
+export type TypeofFloat = number;
 
-- [x] Literal type
-- [ ] Interface type
-- [ ] Literal type
-- [ ] Tuple Type
-- [ ] Base Types
-- [ ] Method Type (Argument Types and Return Types)
-- [ ] Class declaration
-- [ ] Module declaration
-- [ ] Interface declaration
+export type TypeofNumeric = number;
+
+export type TypeofString = string;
+
+export type TypeofBool = boolean;
+
+export type TypeofVoid = void;
+
+export type TypeofUntyped = any;
+
+export type TypeofNil = null;
+
+export type IntegerLiteral = 123;
+
+export type StringLiteral = "abc";
+
+export type TrueLiteral = true;
+
+export type FalseLiteral = false;
+
+export type IntersectionType = string & number & boolean;
+
+export type UnionType = string | number | boolean;
+
+export type ArrayType = string[];
+
+export type TupleType = [];
+
+export type TupleEmptyType = [string, number];
+
+export type OptionalType = string | null | undefined;
+
+export type RecordType = {
+  s: string;
+  next: {
+    i: number;
+    f: number;
+  } | null | undefined;
+};
+
+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;
+  };
+  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)];
+};
+
+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;
+  };
+};
+
+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

@@ -9,6 +9,12 @@ module Rbs2ts
         def to_ts
           decls_ts = @decls.map do |d|
             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
@@ -29,26 +35,109 @@ module Rbs2ts
         end
 
         def name
-          declaration.name.to_s.gsub(/:/, '')
+          declaration.name.name.to_s.gsub(/:/, '')
         end
     
         private
     
         attr_reader :declaration
       end
-  
+
       class Class < Base
+        def to_ts
+          members_ts = declaration.members.map {|member|
+            member_to_ts(member)
+          }.reject(&:empty?).join("\n")
+
+          <<~TS
+            export declare class #{name} {
+            #{Helper.indent(members_ts)}
+            };
+          TS
+          .chomp
+        end
+
+        def member_to_ts(member)
+          case member
+          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
+            Converter::Members::MethodDefinition.new(member).to_ts
+          else
+            ''
+          end
+        end
       end
   
       class Module < Base
+        def to_ts
+          members_ts = declaration.members.map {|member|
+            member_to_ts(member)
+          }.reject(&:empty?).join("\n")
+
+          <<~TS
+            export namespace #{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 #{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
-          "type #{name} = #{Converter::Types::Resolver.to_ts(declaration.type)};"
+          "export type #{name} = #{Converter::Types::Resolver.to_ts(declaration.type)};"
         end
       end
   

data/lib/rbs2ts/converter/helper.rb

@@ -0,0 +1,16 @@
+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
+      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
+          CaseTransform.camel_lower(member.name.to_s.gsub(/:/, ''))
+        end
+    
+        private
+    
+        attr_reader :member
+      end
+
+      class InstanceVariable < Base
+        def to_ts
+          "#{name.gsub(/@/, '')}: #{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,33 +46,43 @@ 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)};"
+            "#{CaseTransform.camel_lower(name.to_s)}: #{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
         end
       end
 
+      class Tuple < ConverterBase
+        def to_ts
+          tuple_types_ts = type.types.map {|t|
+            ts = Types::Resolver.to_ts(t)
+
+            if t.is_a?(::RBS::Types::Union) ||
+              t.is_a?(::RBS::Types::Intersection) ||
+              t.is_a?(::RBS::Types::Optional)
+              "(#{ts})"
+            else
+              ts
+            end
+          }.join(', ')
+
+          "[#{tuple_types_ts}]"
+        end
+      end  
+
       class Literal < ConverterBase
         def to_ts
           case type.literal
@@ -121,12 +131,12 @@ module Rbs2ts
             Types::Array.new(type).to_ts
           when 'String' then
             Types::String.new(type).to_ts
-          when 'Integer' then
+          when 'Numeric', 'Integer', 'Float' then
             Types::Integer.new(type).to_ts
           when 'Bool' then
             Types::Bool.new(type).to_ts
           else
-            type.name.to_s.gsub(/:/, '')
+            type.name.name.to_s.gsub(/:/, '')
           end
         end
       end
@@ -192,6 +202,8 @@ module Rbs2ts
             Types::Intersection
           when ::RBS::Types::Record then
             Types::Record
+          when ::RBS::Types::Tuple then
+            Types::Tuple
           else
             Types::Fallback
           end

data/lib/rbs2ts/version.rb

@@ -1,3 +1,3 @@
 module Rbs2ts
-  VERSION = "1.0.0-alpha.3"
+  VERSION = "1.3.0"
 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.3
+  version: 1.3.0
 platform: ruby
 authors:
 - mugi-uno
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-01-14 00:00:00.000000000 Z
+date: 2021-01-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rbs
@@ -104,6 +104,7 @@ extra_rdoc_files: []
 files:
 - ".circleci/config.yml"
 - ".gitignore"
+- ".prettierignore"
 - ".rspec"
 - ".travis.yml"
 - ".vscode/launch.json"
@@ -117,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
@@ -135,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: []