yard2steep 0.1.0

data/lib/yard2steep/ast/method_node.rb

@@ -0,0 +1,21 @@
+module Yard2steep
+  module AST
+    # MethodNode represents `method` AST.
+    class MethodNode
+      # @dynamic p_list, r_type, m_name
+      attr_reader :p_list, :r_type, :m_name
+
+      # @param [String] m_name
+      # @param [Array<PNode>] p_list
+      # @param [String] r_type
+      def initialize(m_name:, p_list:, r_type:)
+        Util.assert! { m_name.is_a?(String) }
+        Util.assert! { p_list.is_a?(Array) }
+        Util.assert! { r_type.is_a?(String) }
+        @p_list = p_list
+        @r_type = r_type
+        @m_name = m_name
+      end
+    end
+  end
+end

data/lib/yard2steep/ast/p_node.rb

@@ -0,0 +1,23 @@
+module Yard2steep
+  module AST
+    class PNode
+      # @dynamic type_node, style
+      attr_reader :type_node, :style
+
+      STYLE = {
+        normal:               "STYLE.normal",
+        keyword:              "STYLE.keyword",
+        keyword_with_default: "STYLE.keyword_with_default",
+      }
+
+      # @param [AST::PTypeNode] type_node
+      # @param [String] style
+      def initialize(type_node:, style:)
+        Util.assert! { type_node.is_a?(AST::PTypeNode) }
+        Util.assert! { STYLE.values.include?(style) }
+        @type_node = type_node
+        @style     = style
+      end
+    end
+  end
+end

data/lib/yard2steep/ast/p_type_node.rb

@@ -0,0 +1,26 @@
+module Yard2steep
+  module AST
+  # PTypeNode represents `parameter` AST.
+    class PTypeNode
+      # @dynamic p_type, p_name, kind
+      attr_reader :p_type, :p_name, :kind
+
+      KIND = {
+        normal: "KIND.normal",
+        block:  "KIND.block",
+      }
+
+      # @param [String] p_type
+      # @param [String] p_name
+      # @param [String] kind
+      def initialize(p_type:, p_name:, kind:)
+        Util.assert! { p_type.is_a?(String) }
+        Util.assert! { p_name.is_a?(String) }
+        Util.assert! { KIND.values.include?(kind) }
+        @p_type = p_type
+        @p_name = p_name
+        @kind   = kind
+      end
+    end
+  end
+end

data/lib/yard2steep/ast.rb

@@ -0,0 +1,11 @@
+require 'yard2steep/ast/class_node'
+require 'yard2steep/ast/constant_node'
+require 'yard2steep/ast/method_node'
+require 'yard2steep/ast/i_var_node'
+require 'yard2steep/ast/p_node'
+require 'yard2steep/ast/p_type_node'
+
+module Yard2steep
+  module AST
+  end
+end

data/lib/yard2steep/cli/option.rb

@@ -0,0 +1,27 @@
+require 'optparse'
+
+module Yard2steep
+  class CLI
+    class Option
+      # @dynamic src, dst, debug, debug_ast
+      attr_reader :src, :dst, :debug, :debug_ast
+
+      def initialize
+        @src       = '.' # NOTE: Current directory is used as default
+        @dst       = 'sig'
+        @debug     = false
+        @debug_ast = false
+      end
+
+      def parse!(argv)
+        opt = OptionParser.new
+        opt.on('--debug') { |v| @debug = true }
+        opt.on('--debug-ast') { |v| @debug_ast = true }
+        opt.parse!(argv)
+
+        @src = argv[0] if argv[0]
+        @dst = argv[1] if argv[1]
+      end
+    end
+  end
+end

data/lib/yard2steep/cli.rb

@@ -0,0 +1,70 @@
+require 'yard2steep/cli/option'
+
+module Yard2steep
+  class CLI
+    # @param [Array<String>] argv
+    # @return [void]
+    def self.run!(argv)
+      CLI.new(argv).run!
+    end
+
+    # @param [Array<String>] argv
+    def initialize(argv)
+      @option = Option.new
+      @option.parse!(argv)
+    end
+
+    # @return [void]
+    def run!
+      traverse_dir!(src_dir)
+    end
+
+  private
+
+    # @return [String]
+    def src_dir
+      @src_dir ||= File.expand_path(@option.src)
+    end
+
+    # @return [String]
+    def dst_dir
+      @dst_dir ||= File.expand_path(@option.dst)
+    end
+
+    # @param [String] dir
+    # @return [void]
+    def traverse_dir!(dir)
+      Dir.glob(File.join(dir, '*')).each do |f|
+        if File.file?(f)
+          if File.extname(f) == '.rb'
+            translate!(f)
+          end
+        elsif File.directory?(f)
+          traverse_dir!(f)
+        else
+          # Do nothing
+        end
+      end
+    end
+
+    # @param [String] f
+    # @return [void]
+    def translate!(f)
+      text = File.read(f)
+
+      dst_file = File.join(
+        dst_dir,
+        f.gsub(/^#{Regexp.escape(src_dir)}/, '').gsub(/\.rb$/, '.rbi')
+      )
+      dst_dir  = File.dirname(dst_file)
+      FileUtils.mkdir_p(dst_dir)
+      result = Engine.execute(
+        f,
+        text,
+        debug:     @option.debug,
+        debug_ast: @option.debug_ast,
+      )
+      File.write(dst_file, result)
+    end
+  end
+end

data/lib/yard2steep/engine.rb

@@ -0,0 +1,23 @@
+module Yard2steep
+  class Engine
+    # @param [String] file
+    # @param [String] text
+    # @param [bool] debug
+    # @param [bool] debug_ast
+    # @return [String]
+    def self.execute(file, text, debug: false, debug_ast: false)
+      if debug
+        print "## execute\n"
+        print "  file: #{file}\n"
+      end
+
+      ast = Parser.new.parse(file, text, debug: debug)
+
+      if debug_ast
+        print "  ast: #{ast}\n\n"
+      end
+
+      Gen.new.gen(ast)
+    end
+  end
+end

data/lib/yard2steep/gen.rb

@@ -0,0 +1,162 @@
+require 'yard2steep/util'
+
+module Yard2steep
+  class Gen
+    def initialize
+      @out = StringIO.new # Output buffer
+    end
+
+    # @param [AST::ClassNode] ast
+    # @return [String]
+    def gen(ast)
+      gen_child!(ast, off: 0)
+
+      @out.rewind
+      @out.read
+    end
+
+    # @param [String] s
+    # @param [Integer] off
+    # @return [void]
+    def emit!(s, off: 0)
+      Util.assert! { off >= 0 }
+      if off == 0
+        @out.print(s)
+      else
+        @out.print("#{' ' * off}#{s}")
+      end
+    end
+
+    # @param [AST::ClassNode] c_node
+    # @param [Integer] off
+    # @return [void]
+    def gen_child!(c_node, off:)
+      Util.assert! { c_node.is_a?(AST::ClassNode) }
+
+      # TODO(south37) We should check `main` by class_node's type (not name).
+      if c_node.c_name == 'main'
+        # NOTE: In main, steep does not check method type, so we does not
+        # generate type definition of methods.
+        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
+          gen_ivar_list!(c_node, off: off + 2)
+          gen_m_list!(c_node, off: off + 2)
+          emit! "end\n", off: off
+        end
+        gen_c_list!(c_node, off: off)
+        gen_children!(c_node, off: off)
+      end
+    end
+
+    # @param [AST::ClassNode] c_node
+    # @param [Integer] off
+    # @return [void]
+    def gen_m_list!(c_node, off:)
+      c_node.m_list.each do |m_node|
+        gen_m!(m_node, off: off)
+      end
+    end
+
+    # NOTE: In current impl, ivar's type is declared as any
+    #
+    # @param [AST::ClassNode] c_node
+    # @param [Integer] off
+    # @return [void]
+    def gen_ivar_list!(c_node, off:)
+      c_node.ivar_list.each do |ivar_node|
+        emit! "@#{ivar_node.name}: any\n", off: off
+      end
+    end
+
+    # @param [AST::ClassNode] c_node
+    # @param [Integer] off
+    # @return [void]
+    def gen_c_list!(c_node, off:)
+      c_node.c_list.each do |c_node|
+        gen_c!(c_node, off: off)
+      end
+    end
+
+    # @param [AST::ClassNode] c_node
+    # @param [Integer] off
+    # @return [void]
+    def gen_children!(c_node, off:)
+      c_node.children.each do |child|
+        gen_child!(child, off: off)
+      end
+    end
+
+    # @param [AST::ConstantNode] c_node
+    # @param [Integer] off
+    # @return [void]
+    def gen_c!(c_node, off:)
+      Util.assert! { c_node.is_a?(AST::ConstantNode) }
+      # NOTE: Use any as constant type.
+      emit! "#{c_node.long_name}: any\n", off: off
+    end
+
+    # @param [AST::MethodNode] m_node
+    # @param [Integer] off
+    # @return [void]
+    def gen_m!(m_node, off:)
+      Util.assert! { m_node.is_a?(AST::MethodNode) }
+      emit! "def #{m_node.m_name}: ", off: off
+      p_list = m_node.p_list
+
+      # NOTE: Check presence of block variable at last.
+      if p_list[-1] && (p_list[-1].type_node.kind == AST::PTypeNode::KIND[:block])
+        gen_p_list!(p_list[0..-2])
+        gen_block_p!(p_list[-1])
+      else
+        gen_p_list!(p_list)
+      end
+
+      emit! "-> #{m_node.r_type}\n"
+    end
+
+    # @param [Array<AST::PNode>] p_list
+    # @return [void]
+    def gen_p_list!(p_list)
+      len = p_list.size
+      if len > 0
+        emit! "("
+
+        p_list.each.with_index do |p, i|
+          gen_m_p!(p)
+          if i < (len - 1)
+            emit!(", ")
+          end
+        end
+
+        emit! ") "
+      end
+    end
+
+    # TODO(south37) Represents block param and return type separately
+    #
+    # @param [AST::PNode] p
+    # @return [void]
+    def gen_block_p!(p)
+      emit! "#{p.type_node.p_type} "
+    end
+
+    # @param [AST::PNode] p_node
+    # @return [void]
+    def gen_m_p!(p_node)
+      t = p_node.type_node
+
+      case p_node.style
+      when AST::PNode::STYLE[:normal]
+        emit! t.p_type
+      when AST::PNode::STYLE[:keyword]
+        emit! "#{t.p_name}: #{t.p_type}"
+      when AST::PNode::STYLE[:keyword_with_default]
+        emit! "?#{t.p_name}: #{t.p_type}"
+      else
+        raise "invalid style: #{p_node.style}"
+      end
+    end
+  end
+end