yard2steep 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bb6af8f5dee325bf592f102d800a9d740fbe6cf1abf5548487def95356834d39
-  data.tar.gz: 42b2cd5e679580d2b1765cd1a8204a5940f4b4c683dde3b151f061ebe76311c7
+  metadata.gz: 9dd410ad306476662e4768508ddb91363d6881d8714b83588f890b871571e8c2
+  data.tar.gz: a4ea944e7ec8b0ddaec01dfadce13cf85ad934ee1612aeff4ca00b045396f57e
 SHA512:
-  metadata.gz: 60dee77fb6ea4475770849f0f89f44de867a9bcee2d59fdb988443a4edc77945b0540e7932b7a1b3a4f888ef33c97e378f81c3601830d8f90b311905a4c1598e
-  data.tar.gz: 198627709bc5227d0996fdadf7be838421dbacf0c01a3ef34e3ab24af66e90db02ee96cea76c1e02732f94578207aae3fc54a5cb06f891cf0365e1c8f8afe0e5
+  metadata.gz: ca073d5d4eba5d8caad1d94877b9d7800cd1ec10306f2f02e8bc36cd37695e70a5e571c30aafeec27f0e42842e25ac34e46d1115f0534a39c846085612d97e1e
+  data.tar.gz: 470f49608f90134ce4cddee5e9a905371347ae3ad8eb49b245a2d8fab83b8be8b5d9d82fb813cf2389c49fdfecbb6c23f9f32b9ac2973bcd46010ba0a410ec7e

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    yard2steep (0.1.0)
+    yard2steep (0.1.1)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -2,7 +2,7 @@
 
 Generate [steep](https://github.com/soutaro/steep) type definition file from yard annotation.
 
-:warning: **This is highly experimental project. Current version is 0.1.0.**
+:warning: **This is highly experimental project. Current version is 0.1.1.**
 
 ## Installation
 

data/example/sample1/lib/example1.rb

@@ -12,6 +12,11 @@ end
 # NOTE: this is wrong comment. so should ignore it
 # @param [Array] contents
 
+class SomeClass
+  # @dynamic index
+  attr_reader :index
+end
+
 class MyClass
   # NOTE: method definition in singleton class should be ignored
   class << self
@@ -24,8 +29,6 @@ class MyClass
 
   CONSTANT = "This is constant".freeze
 
-  attr_reader :index
-
   # This for should not be used.
   # @return [String]
   def self.name
@@ -42,6 +45,11 @@ class MyClass
     [:ok, :no]
   end
 
+  # @return [Array<Array<Symbol>>]
+  def nest
+    [[:o]]
+  end
+
   # @return [Array(Symbol, Integer)]
   def type
     [:number, 1]
@@ -58,6 +66,11 @@ class MyClass
     { ok: 3, no: nil }
   end
 
+  # @return [Hash{ Symbol => Array<Integer> }]
+  def nest_hash
+    { ok: [1, 2] }
+  end
+
   # @param [Array<Integer>] contents
   # @param [Symbol] order
   # @return [Array<Integer>]

data/example/sample1/sig/example1.rbi

@@ -1,12 +1,16 @@
-class MyClass
+class SomeClass
   @index: any
   def index: -> any
+end
+class MyClass
   def self.name: -> String
   def name: -> String
   def pair: -> Array<Symbol>
+  def nest: -> Array<Array<Symbol>>
   def type: -> Array<Symbol | Integer>
   def opts: -> Hash<any, any>
   def values: (?off: Integer) -> Hash<Symbol, Integer | nil>
+  def nest_hash: -> Hash<Symbol, Array<Integer>>
   def reverse: (Array<Integer>, order: Symbol) -> Array<Integer>
   def first!: (any) -> any
   def present?: (any) -> any
@@ -16,6 +20,6 @@ MyClass::CONSTANT: any
 module MyClass::InnerClass
   def double: (source: Integer) -> Integer
 end
-class OtherClass
+class OtherClass <: MyClass
   def yes: -> any
 end

data/lib/yard2steep/ast/class_node.rb

@@ -7,19 +7,21 @@ module Yard2steep
         AST::ClassNode.new(
           kind:   'module',
           c_name: 'main',
-          parent: nil,
+          super_c: nil,
+          parent:  nil,
         )
       end
 
-      # @dynamic kind, c_name, c_list, m_list, ivar_list, children, parent
-      attr_reader :kind, :c_name, :c_list, :m_list, :ivar_list, :children, :parent
+      # @dynamic kind, c_name, super_c, c_list, m_list, ivar_list, children, parent
+      attr_reader :kind, :c_name, :super_c, :c_list, :m_list, :ivar_list, :children, :parent
 
       KIND = ['class', 'module']
 
       # @param [String] kind
       # @param [String] c_name
-      # @param [AST::ClassNode | nil] parent
-      def initialize(kind:, c_name:, parent:)
+      # @param [AST::ClassNode, nil] parent
+      # @param [String, nil] super_c
+      def initialize(kind:, c_name:, super_c:, parent:)
         Util.assert! { KIND.include?(kind) }
         Util.assert! { c_name.is_a?(String) }
         Util.assert! {
@@ -28,6 +30,7 @@ module Yard2steep
         }
         @kind      = kind
         @c_name    = c_name
+        @super_c   = super_c
         @c_list    = []  # list of constants
         @m_list    = []  # list of methods
         @ivar_list = []  # list of instance variables
@@ -73,6 +76,16 @@ module Yard2steep
         end
       end
 
+      def long_super
+        @long_super ||= begin
+           if @parent.c_name == 'main'
+             @super_c
+           else
+             "#{@parent.long_name}::#{@super_c}"
+           end
+        end
+      end
+
       # @return [String]
       def to_s
         inspect

data/lib/yard2steep/gen.rb

@@ -40,7 +40,7 @@ module Yard2steep
         gen_children!(c_node, off: 0)
       else
         if (c_node.m_list.size > 0) || (c_node.ivar_list.size > 0)
-          emit! "#{c_node.kind} #{c_node.long_name}\n", off: off
+          emit! "#{c_node.kind} #{c_node.long_name}#{c_node.super_c ? " <: #{c_node.long_super}" : nil}\n", off: off
           gen_ivar_list!(c_node, off: off + 2)
           gen_m_list!(c_node, off: off + 2)
           emit! "end\n", off: off

data/lib/yard2steep/parser.rb

@@ -1,4 +1,5 @@
 require 'yard2steep/ast'
+require 'yard2steep/type'
 
 module Yard2steep
   class Parser
@@ -12,7 +13,7 @@ module Yard2steep
       (class)
       #{S_P_RE}
       (\w+)
-      (?:
+      (
         #{S_P_RE}
         <
         #{S_P_RE}
@@ -60,7 +61,14 @@ module Yard2steep
     $/x
 
     COMMENT_RE         = /#{PRE_RE}#/
-    TYPE_WITH_PAREN_RE = /\[([^\]]*)\]/
+    TYPE_WITH_PAREN_RE = /
+      \[
+      (
+        [^\]]
+        *
+      )
+      \]
+    /x
 
     PARAM_RE  = /
       #{COMMENT_RE}
@@ -280,9 +288,10 @@ module Yard2steep
       reset_method_context!
 
       c = AST::ClassNode.new(
-        kind:   m[1],
-        c_name: m[2],
-        parent: @current_class,
+        kind:    m[1],
+        c_name:  m[2],
+        super_c: m[3] && m[3].gsub('<', '').strip,
+        parent:  @current_class,
       )
       @current_class.append_child(c)
       @current_class = c
@@ -516,69 +525,11 @@ module Yard2steep
       print "#{' ' * (@stack.size * 2 + offset)}#{message}\n" if @debug
     end
 
-    ARRAY_TYPE_RE = /^
-      Array
-      #{S_RE}
-      <
-        ([^>]+)
-      >
-      #{S_RE}
-    $/x
-    FIXED_ARRAY_TYPE_RE = /^
-      Array
-      #{S_RE}
-      \(
-        ([^)]+)
-      \)
-      #{S_RE}
-    $/x
-    HASH_TYPE_RE = /^
-      Hash
-      #{S_RE}
-      \{
-        #{S_RE}
-        ([^=]+)
-        #{S_RE}
-        =>
-        #{S_RE}
-        ([^}]+)
-        #{S_RE}
-      \}
-      #{S_RE}
-    $/x
-
-    # NOTE: normalize type to steep representation
-    #
     # @param [String] type
     # @return [String]
     def normalize_type(type)
-      if type[0..4] == 'Array'.freeze
-        if type == 'Array'.freeze
-          'Array<any>'.freeze
-        elsif (m = ARRAY_TYPE_RE.match(type))
-          "Array<#{normalize_multi_type(m[1])}>"
-        elsif (m = FIXED_ARRAY_TYPE_RE.match(type))
-          "Array<#{normalize_multi_type(m[1])}>"
-        else
-          raise "invalid Array type: #{type}"
-        end
-      elsif type[0..3] == 'Hash'.freeze
-        if type == 'Hash'.freeze
-          'Hash<any, any>'.freeze
-        elsif (m = HASH_TYPE_RE.match(type))
-          "Hash<#{normalize_multi_type(m[1])}, #{normalize_multi_type(m[2])}>"
-        else
-          raise "invalid Hash type: #{type}"
-        end
-      else
-        normalize_multi_type(type)
-      end
-    end
-
-    # @param [String] type_s
-    # @return [String]
-    def normalize_multi_type(type_s)
-      type_s.split(',').map { |s| s.strip }.uniq.join(' | ')
+      debug_print! type
+      Type.translate(type)
     end
   end
 end

data/lib/yard2steep/type/ast.rb

@@ -0,0 +1,52 @@
+module Yard2steep
+  class Type
+    class TypeBase
+      # @param [Array<TypeBase>] types
+      # @return [String]
+      def self.union2s(types)
+        types.map { |t| t.to_s }.uniq.join(' | ')
+      end
+    end
+
+    class AnyType < TypeBase
+      def to_s
+        'any'
+      end
+    end
+
+    class NormalType < TypeBase
+      # @param [String] type
+      def initialize(type:)
+        @type = type
+      end
+
+      def to_s
+        @type
+      end
+    end
+
+    class ArrayType < TypeBase
+      # @param [Array<TypeBase>] type
+      def initialize(type:)
+        @type = type
+      end
+
+      def to_s
+        "Array<#{TypeBase.union2s(@type)}>"
+      end
+    end
+
+    class HashType < TypeBase
+      # @param [Array<TypeBase>] key
+      # @param [Array<TypeBase>] val
+      def initialize(key:, val:)
+        @key = key
+        @val = val
+      end
+
+      def to_s
+        "Hash<#{TypeBase.union2s(@key)}, #{TypeBase.union2s(@val)}>"
+      end
+    end
+  end
+end

data/lib/yard2steep/type/parser.rb

@@ -0,0 +1,145 @@
+module Yard2steep
+  class Type
+    class Parser
+      # @param [Array<String>]
+      # @return [Array<TypeBase>]
+      def self.parse(tokens)
+        Parser.new(tokens).parse
+      end
+
+      # @param [Array<String>]
+      def initialize(tokens)
+        @tokens = tokens
+        @types  = []
+      end
+
+      # @reutrn [Array<TypeBase>]
+      def parse
+        debug_print!(@tokens)
+
+        return [] if (@tokens.size == 0)
+
+        @types.push(parse_type)
+        while @tokens.size > 0
+          expect!(',')
+          @types.push(parse_type)
+        end
+
+        @types
+      end
+
+    private
+
+      # @return [TypeBase]
+      def parse_type
+        t = get
+        Util.assert! { t }
+
+        case t
+        when 'Array'
+          r = parse_array
+        when 'Hash'
+          r = parse_hash
+        else
+          r = parse_normal_type(t)
+        end
+
+        debug_print! "type: #{r}\n"
+        debug_print! "peek: #{peek}\n"
+
+        r
+      end
+
+      # @param [String] t
+      # @return [NormalType]
+      def parse_normal_type(t)
+        NormalType.new(type: t)
+      end
+
+      # @param [String] term_s
+      # @return [Array<TypeBase>]
+      def parse_multiple_types(term_s)
+        t = peek
+        if t == term_s
+          expect!(term_s)
+          return []
+        end
+
+        r = []
+        r.push(parse_type)
+
+        while t = peek
+          break if t != ','
+          expect!(',')
+          r.push(parse_type)
+        end
+
+        debug_print! "term_s: #{term_s}\n"
+        expect!(term_s)
+
+        r
+      end
+
+      # @return [ArrayType]
+      def parse_array
+        case peek
+        when '<'
+          expect!('<')
+          ArrayType.new(
+            type: parse_multiple_types('>')
+          )
+        when '('
+          expect!('(')
+          ArrayType.new(
+            type: parse_multiple_types(')')
+          )
+        else
+          ArrayType.new(
+            type: [AnyType.new]
+          )
+        end
+      end
+
+      def parse_hash
+        debug_print!("parse_hash, peek: #{peek}")
+
+        case peek
+        when '{'
+          expect!('{')
+          key = parse_multiple_types('=')
+          expect!('>')
+          val = parse_multiple_types('}')
+          HashType.new(
+            key: key,
+            val: val,
+          )
+        else
+          HashType.new(
+            key: [AnyType.new],
+            val: [AnyType.new],
+          )
+        end
+      end
+
+      # @param [String] token
+      def expect!(token)
+        t = get
+        Util.assert! { t == token }
+      end
+
+      def get
+        @tokens.shift
+      end
+
+      def peek
+        @tokens[0]
+      end
+
+      # @param [String] message
+      def debug_print!(message)
+        # TODO(south37) Add flag
+        # print message
+      end
+    end
+  end
+end

data/lib/yard2steep/type.rb

@@ -0,0 +1,41 @@
+require 'strscan'
+require 'yard2steep/type/ast'
+require 'yard2steep/type/parser'
+
+module Yard2steep
+  class Type
+    # @param [Strng]
+    # @return [String]
+    def self.translate(text)
+      Type.new(text).translate
+    end
+
+    # @param [String] text
+    def initialize(text)
+      @text = text
+    end
+
+    def translate
+      tokens = tokens(@text)
+      ast = Parser.parse(tokens)
+      TypeBase.union2s(ast)
+    end
+
+    S_RE = /[\s\t]*/
+    TOKENS = /
+      [<>(),|={}]|[\w:]+
+    /x
+
+    # @param [String] str
+    # @return [Array<String>]
+    def tokens(str)
+      r = []
+      s = StringScanner.new(str)
+      while !s.eos?
+        s.scan(S_RE)
+        r.push(s.scan(TOKENS))
+      end
+      r
+    end
+  end
+end

data/lib/yard2steep/version.rb

@@ -1,3 +1,3 @@
 module Yard2steep
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/sig/steep-scaffold/td.rbi

@@ -35,7 +35,6 @@ class Yard2steep::Parser
   def type_node: (any) -> any
   def debug_print!: (any, ?offset: Integer) -> void
   def normalize_type: (any) -> any
-  def normalize_multi_type: (any) -> any
 end
 
 Yard2steep::Parser::S_RE: Regexp
@@ -60,9 +59,6 @@ Yard2steep::Parser::ATTR_RE: Regexp
 Yard2steep::Parser::STATES: Hash<any, any>
 Yard2steep::Parser::ANY_TYPE: String
 Yard2steep::Parser::ANY_BLOCK_TYPE: String
-Yard2steep::Parser::ARRAY_TYPE_RE: Regexp
-Yard2steep::Parser::FIXED_ARRAY_TYPE_RE: Regexp
-Yard2steep::Parser::HASH_TYPE_RE: Regexp
 class Yard2steep::CLI
   @option: any
   @src_dir: any
@@ -89,6 +85,60 @@ class Yard2steep::Engine
   def self.execute: (any, any, ?debug: bool, ?debug_ast: bool) -> any
 end
 
+class Yard2steep::Type::TypeBase
+  def self.union2s: (any) -> any
+end
+
+class Yard2steep::Type::AnyType
+  def to_s: () -> String
+end
+
+class Yard2steep::Type::NormalType
+  @type: any
+  def initialize: (type: any) -> any
+  def to_s: () -> any
+end
+
+class Yard2steep::Type::ArrayType
+  @type: any
+  def initialize: (type: any) -> any
+  def to_s: () -> String
+end
+
+class Yard2steep::Type::HashType
+  @key: any
+  @val: any
+  def initialize: (key: any, val: any) -> any
+  def to_s: () -> String
+end
+
+class Yard2steep::Type::Parser
+  @tokens: any
+  @types: any
+  def initialize: (any) -> Array<any>
+  def parse: () -> any
+  def parse_type: () -> any
+  def parse_normal_type: (any) -> any
+  def parse_multiple_types: (any) -> any
+  def parse_array: () -> any
+  def parse_hash: () -> any
+  def expect!: (any) -> any
+  def get: () -> any
+  def peek: () -> any
+  def debug_print!: (any) -> any
+  def self.parse: (any) -> any
+end
+
+class Yard2steep::Type
+  @text: any
+  def initialize: (any) -> any
+  def translate: () -> any
+  def tokens: (any) -> any
+  def self.translate: (any) -> any
+end
+
+Yard2steep::Type::S_RE: Regexp
+Yard2steep::Type::TOKENS: Regexp
 module Yard2steep::Util
   def self.assert!: { () -> any } -> void
 end
@@ -106,18 +156,21 @@ end
 class Yard2steep::AST::ClassNode
   @kind: any
   @c_name: any
+  @super_c: any
   @c_list: any
   @m_list: any
   @ivar_list: any
   @children: any
   @parent: any
   @long_name: any
-  def initialize: (kind: any, c_name: any, parent: any) -> any
+  @long_super: any
+  def initialize: (kind: any, c_name: any, super_c: any, parent: any) -> any
   def append_constant: (any) -> any
   def append_m: (any) -> any
   def append_ivar: (any) -> any
   def append_child: (any) -> any
   def long_name: () -> any
+  def long_super: () -> any
   def to_s: () -> any
   def inspect: () -> String
   def self.create_main: () -> any

data/sig/yard2steep/yard2steep/ast/class_node.rbi

@@ -1,6 +1,7 @@
 class Yard2steep::AST::ClassNode
   @kind: any
   @c_name: any
+  @super_c: any
   @c_list: any
   @m_list: any
   @ivar_list: any
@@ -9,17 +10,19 @@ class Yard2steep::AST::ClassNode
   def self.create_main: -> AST::ClassNode
   def kind: -> any
   def c_name: -> any
+  def super_c: -> any
   def c_list: -> any
   def m_list: -> any
   def ivar_list: -> any
   def children: -> any
   def parent: -> any
-  def initialize: (kind: String, c_name: String, parent: AST::ClassNode | nil) -> any
+  def initialize: (kind: String, c_name: String, super_c: String | nil, parent: AST::ClassNode | nil) -> any
   def append_constant: (AST::ConstantNode) -> void
   def append_m: (AST::MethodNode) -> void
   def append_ivar: (AST::IVarNode) -> void
   def append_child: (AST::ClassNode) -> void
   def long_name: -> String
+  def long_super: -> any
   def to_s: -> String
   def inspect: -> String
 end

data/sig/yard2steep/yard2steep/parser.rbi

@@ -23,7 +23,6 @@ class Yard2steep::Parser
   def type_node: (String) -> AST::PTypeNode
   def debug_print!: (String, ?offset: Integer) -> void
   def normalize_type: (String) -> String
-  def normalize_multi_type: (String) -> String
 end
 Yard2steep::Parser::S_RE: any
 Yard2steep::Parser::S_P_RE: any
@@ -47,6 +46,3 @@ Yard2steep::Parser::ATTR_RE: any
 Yard2steep::Parser::STATES: any
 Yard2steep::Parser::ANY_TYPE: any
 Yard2steep::Parser::ANY_BLOCK_TYPE: any
-Yard2steep::Parser::ARRAY_TYPE_RE: any
-Yard2steep::Parser::FIXED_ARRAY_TYPE_RE: any
-Yard2steep::Parser::HASH_TYPE_RE: any

data/sig/yard2steep/yard2steep/type/ast.rbi

@@ -0,0 +1,18 @@
+class Yard2steep::Type::TypeBase
+  def self.union2s: (Array<TypeBase>) -> String
+end
+class Yard2steep::Type::AnyType <: Yard2steep::Type::TypeBase
+  def to_s: -> any
+end
+class Yard2steep::Type::NormalType <: Yard2steep::Type::TypeBase
+  def initialize: (type: String) -> any
+  def to_s: -> any
+end
+class Yard2steep::Type::ArrayType <: Yard2steep::Type::TypeBase
+  def initialize: (type: Array<TypeBase>) -> any
+  def to_s: -> any
+end
+class Yard2steep::Type::HashType <: Yard2steep::Type::TypeBase
+  def initialize: (key: Array<TypeBase>, val: Array<TypeBase>) -> any
+  def to_s: -> any
+end

data/sig/yard2steep/yard2steep/type/parser.rbi

@@ -0,0 +1,14 @@
+class Yard2steep::Type::Parser
+  def self.parse: (any) -> Array<TypeBase>
+  def initialize: (any) -> any
+  def parse: -> any
+  def parse_type: -> TypeBase
+  def parse_normal_type: (String) -> NormalType
+  def parse_multiple_types: (String) -> Array<TypeBase>
+  def parse_array: -> ArrayType
+  def parse_hash: -> any
+  def expect!: (String) -> any
+  def get: -> any
+  def peek: -> any
+  def debug_print!: (String) -> any
+end

data/sig/yard2steep/yard2steep/type.rbi

@@ -0,0 +1,8 @@
+class Yard2steep::Type
+  def self.translate: (any) -> String
+  def initialize: (String) -> any
+  def translate: -> any
+  def tokens: (String) -> Array<String>
+end
+Yard2steep::Type::S_RE: any
+Yard2steep::Type::TOKENS: any

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: yard2steep
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Nao Minami
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-06-27 00:00:00.000000000 Z
+date: 2018-06-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -118,6 +118,9 @@ files:
 - lib/yard2steep/engine.rb
 - lib/yard2steep/gen.rb
 - lib/yard2steep/parser.rb
+- lib/yard2steep/type.rb
+- lib/yard2steep/type/ast.rb
+- lib/yard2steep/type/parser.rb
 - lib/yard2steep/util.rb
 - lib/yard2steep/version.rb
 - sig/steep-scaffold/td.rbi
@@ -134,6 +137,9 @@ files:
 - sig/yard2steep/yard2steep/engine.rbi
 - sig/yard2steep/yard2steep/gen.rbi
 - sig/yard2steep/yard2steep/parser.rbi
+- sig/yard2steep/yard2steep/type.rbi
+- sig/yard2steep/yard2steep/type/ast.rbi
+- sig/yard2steep/yard2steep/type/parser.rbi
 - sig/yard2steep/yard2steep/util.rbi
 - sig/yard2steep/yard2steep/version.rbi
 - yard2steep.gemspec