rbs2ts 1.0.0.pre.alpha.2 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 475224f8b22d01a2d3e11e6f4988ce8b96aaa36c1d6b7692d1a48f7e6ff9d7cc
-  data.tar.gz: 1274cd9d2b5d516b8d1e88e283a68e6e3c76686fecfa83f9dcd030090e60f21c
+  metadata.gz: 63451fb8675f6e0e4420d64d7655385f8b32260c0e17b0ec9f796312372140b3
+  data.tar.gz: cfa90fb4ec6d06efc412ec1f1f28a000d23c3f16cba28ad0aa5f4cea4d2bda43
 SHA512:
-  metadata.gz: 6e193c1144b33b6d12b792554ec288bfaf0a070c8d40cae480b64b7e23a875b32dbb1801d32e779443c78614681f75b45752ed82f2c7909e7694a0b41a972da1
-  data.tar.gz: 6bbc894fba29723892e8dd7f4c98dd25c014abd58e18d9423215ac9bf1e13dc4237e0c875e4e6984543de80b52465aef19330adbfb34799ae2ba732d3166346e
+  metadata.gz: e8e8b4381ee67f4ad40a5a5cafa2590efe7f698b3f98bbc9625a0f74c975c4924cfd713a4450c67ba45bb346b3f620f2445707c27e09153eefe12ce60b21873a
+  data.tar.gz: 60832356723c81313fc06afa80a88d16555b815e3c94090db05392bee17f2de7bb30d8a5682cfdd04eaacbd4deeffdb4c1f6df5932b4bb21e5bee357aefdad9e

data/.circleci/config.yml

@@ -0,0 +1,18 @@
+version: 2.1
+orbs:
+  ruby: circleci/ruby@0.1.2 
+
+jobs:
+  build:
+    docker:
+      - image: circleci/ruby:3
+    executor: ruby/default
+    steps:
+      - checkout
+      - run:
+          name: Bundle Install
+          command: bundle -v
+      - ruby/bundle-install
+      - run:
+          name: RSpec
+          command: bundle exec rspec

data/.gitignore

@@ -56,5 +56,4 @@ Gemfile.lock
 
 # Used by RuboCop. Remote config files pulled in from inherit_from directive.
 # .rubocop-https?--*
-
-
+.rspec_status

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/Gemfile

@@ -7,3 +7,5 @@ gemspec
 
 gem "debase"
 gem "ruby-debug-ide"
+gem "pry"
+gem "pry-byebug"

data/README.md

@@ -1,6 +1,6 @@
 # Rbs2ts
 
-Convert RBS to TypeScript type definition.
+A RubyGem that converts Ruby RBS to TypeScript definitions.
 
 ## Installation
 
@@ -13,3 +13,182 @@ 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
+  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
+  def func: (String, Integer) -> { str: String, int: Integer }
+end
+
+interface _Interface
+  def func: (String, Integer) -> { str: String, int: Integer }
+end
+```
+
+to TypeScript
+
+```typescript
+export type TypeofInteger = number;
+
+export type TypeofFloat = number;
+
+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 {
+  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 function func(arg1: string, arg2: number): {
+    str: string;
+    int: number;
+  };
+};
+
+export interface Interface {
+  func(arg1: string, arg2: number): {
+    str: string;
+    int: number;
+  };
+};
+```

data/lib/rbs2ts/cli.rb

@@ -1,17 +1,19 @@
 require "thor"
 require "rbs2ts/converter"
-  
+
 module Rbs2ts 
   class Cli < Thor
     desc "convert rbs to ts", "convert rbs to ts"
     def convert(path)
+      ::RBS.logger_level = :error
+
       loader = ::RBS::EnvironmentLoader.new(core_root: nil)
 
       loader.add(path: Pathname(path))
 
       env = ::RBS::Environment.from_loader(loader).resolve_type_names
 
-      Converter::Declarations::Declarations.new(env.declarations).to_ts
+      puts Converter::Declarations::Declarations.new(env.declarations).to_ts
     end
   end
 end

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,12 +9,18 @@ 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
           end
 
-          puts decls_ts.join("\n\n")
+          decls_ts.join("\n\n")
         end
       end
   
@@ -36,19 +42,89 @@ module Rbs2ts
     
         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::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::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,140 @@
+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 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,56 @@ 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
+          when ::String then
+            "\"#{type.literal}\""
+          when ::Integer, ::TrueClass, ::FalseClass then
+            "#{type.literal}"
+          else
+            'unknown'
+          end
+        end
+      end
+
       class Optional < ConverterBase
         def to_ts
           "#{Types::Resolver.to_ts(type.type)} | null | undefined"
@@ -108,7 +131,7 @@ 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
@@ -169,6 +192,8 @@ module Rbs2ts
             Types::BasesNil
           when ::RBS::Types::ClassInstance then
             Types::ClassInstance
+          when ::RBS::Types::Literal then
+            Types::Literal
           when ::RBS::Types::Optional then
             Types::Optional
           when ::RBS::Types::Union then
@@ -177,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.2"
+  VERSION = "1.2.0"
 end

data/rbs2ts.gemspec

@@ -9,25 +9,10 @@ Gem::Specification.new do |spec|
   spec.authors       = ["mugi-uno"]
   spec.email         = ["mugi.uno@gmail.com"]
 
-  spec.summary       = "Convert rbs to typescript"
-  spec.description   = "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"
 
-  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
-  # to allow pushing to a single host or delete this section to allow pushing to any host.
-  if spec.respond_to?(:metadata)
-    # spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
-
-    # spec.metadata["homepage_uri"] = spec.homepage
-    # spec.metadata["source_code_uri"] = "TODO: Put your gem's public repo URL here."
-    # spec.metadata["changelog_uri"] = "TODO: Put your gem's CHANGELOG.md URL here."
-  else
-    raise "RubyGems 2.0 or newer is required to protect against " \
-      "public gem pushes."
-  end
-
-  # Specify which files should be added to the gem when it is released.
-  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
   spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
     `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   end
@@ -39,7 +24,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency "thor"
   spec.add_dependency "case_transform"
 
-  spec.add_development_dependency "bundler", "~> 2.1.4"
+  spec.add_development_dependency "bundler", ">= 2.1.4"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rbs2ts
 version: !ruby/object:Gem::Version
-  version: 1.0.0.pre.alpha.2
+  version: 1.2.0
 platform: ruby
 authors:
 - mugi-uno
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-01-13 00:00:00.000000000 Z
+date: 2021-01-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rbs
@@ -56,14 +56,14 @@ dependencies:
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: 2.1.4
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: 2.1.4
 - !ruby/object:Gem::Dependency
@@ -94,7 +94,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
-description: Convert rbs to typescript
+description:
 email:
 - mugi.uno@gmail.com
 executables:
@@ -102,7 +102,9 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- ".circleci/config.yml"
 - ".gitignore"
+- ".prettierignore"
 - ".rspec"
 - ".travis.yml"
 - ".vscode/launch.json"
@@ -116,11 +118,14 @@ 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
 homepage: https://github.com/mugi-uno/rbs2ts
-licenses: []
+licenses:
+- MIT
 metadata: {}
 post_install_message:
 rdoc_options: []
@@ -133,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: []