yard2steep 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: bb6af8f5dee325bf592f102d800a9d740fbe6cf1abf5548487def95356834d39
+  data.tar.gz: 42b2cd5e679580d2b1765cd1a8204a5940f4b4c683dde3b151f061ebe76311c7
+SHA512:
+  metadata.gz: 60dee77fb6ea4475770849f0f89f44de867a9bcee2d59fdb988443a4edc77945b0540e7932b7a1b3a4f888ef33c97e378f81c3601830d8f90b311905a4c1598e
+  data.tar.gz: 198627709bc5227d0996fdadf7be838421dbacf0c01a3ef34e3ab24af66e90db02ee96cea76c1e02732f94578207aae3fc54a5cb06f891cf0365e1c8f8afe0e5

data/.gitignore

@@ -0,0 +1,52 @@
+tags
+
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+# Used by dotenv library to load environment variables.
+# .env
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+*.bridgesupport
+build-iPhoneOS/
+build-iPhoneSimulator/
+
+## Specific to RubyMotion (use of CocoaPods):
+#
+# We recommend against adding the Pods directory to your .gitignore. However
+# you should judge for yourself, the pros and cons are mentioned at:
+# https://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control
+#
+# vendor/Pods/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalization:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.5.0
+before_install: gem install bundler -v 1.16.1

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in yard2steep.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,68 @@
+PATH
+  remote: .
+  specs:
+    yard2steep (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (5.1.6)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 0.7, < 2)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
+    ast (2.4.0)
+    ast_utils (0.1.0)
+      parser (~> 2.4)
+      thor (~> 0.19.4)
+    coderay (1.1.2)
+    concurrent-ruby (1.0.5)
+    diff-lcs (1.3)
+    i18n (1.0.1)
+      concurrent-ruby (~> 1.0)
+    method_source (0.9.0)
+    minitest (5.11.3)
+    parser (2.5.1.0)
+      ast (~> 2.4.0)
+    pry (0.11.3)
+      coderay (~> 1.1.0)
+      method_source (~> 0.9.0)
+    rainbow (2.2.2)
+      rake
+    rake (10.5.0)
+    rspec (3.7.0)
+      rspec-core (~> 3.7.0)
+      rspec-expectations (~> 3.7.0)
+      rspec-mocks (~> 3.7.0)
+    rspec-core (3.7.1)
+      rspec-support (~> 3.7.0)
+    rspec-expectations (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-mocks (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-support (3.7.1)
+    steep (0.4.0)
+      activesupport (~> 5.1.0)
+      ast_utils (~> 0.1.0)
+      parser (~> 2.4)
+      rainbow (~> 2.2.2)
+    thor (0.19.4)
+    thread_safe (0.3.6)
+    tzinfo (1.2.5)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.16)
+  pry
+  rake (~> 10.0)
+  rspec (~> 3.2)
+  steep (= 0.4.0)
+  yard2steep!
+
+BUNDLED WITH
+   1.16.2

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Nao Minami
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,86 @@
+# Yard2steep
+
+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.**
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'yard2steep'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install yard2steep
+
+## Usage
+
+`yard2steep` generates steep type definition file from yard annotation.
+
+```console
+$ yard2steep lib sig
+```
+
+```ruby
+# lib/parser.rb
+class AST
+  # @return [String]
+  def to_s
+    # Do something
+    "AST"
+  end
+end
+
+class Parser
+  # @param [String] text
+  # @return [AST]
+  def parse(text)
+    ast = AST.new
+    # Do something
+    ast
+  end
+end
+```
+
+`sig/parser.rbi` is generated.
+
+```ruby
+# sig/parser.rbi
+class AST
+  def to_s: -> String
+end
+class Parser
+  def parse: (String) -> AST
+end
+```
+
+After generating `.rbi` file, we can run `steep check` command to type check. (cf. [Usage of steep](https://github.com/soutaro/steep#usage) )
+
+```
+$ steep check lib -I sig
+```
+
+Congraturation! :tada:
+You did type checking by yard annotation!
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake true` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/south37/yard2steep.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "yard2steep"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/bin/steep-check

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+
+# Check with generated file
+echo "steep check with steep-scaffold"
+bundle exec steep check lib -I sig/steep-scaffold
+
+echo "steep check with yard2steep"
+bundle exec steep check lib -I sig/yard2steep

data/bin/steep-gen

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+
+print "Generate interface with steep-scaffold\n"
+TARGET = 'sig/steep-scaffold/td.rbi'
+# Update sig/steep-scaffold/td.rbi
+%x{ bundle exec steep scaffold lib > #{TARGET} }
+# Postfix
+text = File.read(TARGET)
+# Fix block type
+text = text.gsub('def self.assert!: () -> void', 'def self.assert!: { () -> any } -> void')
+# Fix duplicated `module Yard2steep
+text = text.split("\n")[0..-3].join("\n") + "\n"
+File.write(TARGET, text)
+
+print "Generate interface with yard2steep\n"
+%x{ bundle exec yard2steep lib sig/yard2steep }

data/bin/steep-gen-check

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+
+# Generate interface
+bin/steep-gen
+
+# Check interface
+bin/steep-check

data/example/sample1/lib/example1.rb

@@ -0,0 +1,107 @@
+# @param [Array] contents
+# @return [Symbol]
+def first(contents:)
+  # .
+  # .
+  # .
+  # NOTE: this is wrong comment. so should ignore it
+  # @param [Array] contents
+  []
+end
+
+# NOTE: this is wrong comment. so should ignore it
+# @param [Array] contents
+
+class MyClass
+  # NOTE: method definition in singleton class should be ignored
+  class << self
+    # @return [String]
+    def ok
+      return 'no' if true
+      'ok'
+    end
+  end
+
+  CONSTANT = "This is constant".freeze
+
+  attr_reader :index
+
+  # This for should not be used.
+  # @return [String]
+  def self.name
+    'name'
+  end
+
+  # @return [String]
+  def name
+    'name'
+  end
+
+  # @return [Array(Symbol, Symbol)]
+  def pair
+    [:ok, :no]
+  end
+
+  # @return [Array(Symbol, Integer)]
+  def type
+    [:number, 1]
+  end
+
+  # @return [Hash]
+  def opts
+    {}
+  end
+
+  # @param [Integer] off
+  # @return [Hash{ Symbol => Integer, nil }]
+  def values(off: 0)
+    { ok: 3, no: nil }
+  end
+
+  # @param [Array<Integer>] contents
+  # @param [Symbol] order
+  # @return [Array<Integer>]
+  def reverse contents, order:
+    if order == :normal
+      return []
+    end
+
+    case order
+    when :other then return []
+    else
+      raise "invalid"
+    end
+    # .
+    # .
+    # .
+    # NOTE: this is wrong comment. so should ignore it
+    # @param [Array] contents
+    []
+  end
+
+  # NOTE: should be interpreterd as any -> any
+  def first!(list)
+    list.last
+  end
+
+  # NOTE: should be interpreterd as any -> any
+  def present?(list)
+    list.size > 0
+  end
+
+  def mysum(list, &block)
+    list.map { |e| block.call(e) }.inject(&:+)
+  end
+
+  module InnerClass
+    # @param [Integer] source
+    # @return [Integer]
+    def double(source:); source * 2; end
+  end
+end
+
+class OtherClass < MyClass
+  def yes
+    'yes'
+  end
+end

data/example/sample1/sig/example1.rbi

@@ -0,0 +1,21 @@
+class MyClass
+  @index: any
+  def index: -> any
+  def self.name: -> String
+  def name: -> String
+  def pair: -> Array<Symbol>
+  def type: -> Array<Symbol | Integer>
+  def opts: -> Hash<any, any>
+  def values: (?off: Integer) -> Hash<Symbol, Integer | nil>
+  def reverse: (Array<Integer>, order: Symbol) -> Array<Integer>
+  def first!: (any) -> any
+  def present?: (any) -> any
+  def mysum: (any) { (any) -> any } -> any
+end
+MyClass::CONSTANT: any
+module MyClass::InnerClass
+  def double: (source: Integer) -> Integer
+end
+class OtherClass
+  def yes: -> any
+end

data/example/sample2/lib/2.rb

@@ -0,0 +1,68 @@
+class Person
+  # `@dynamic` annotation is to tell steep that
+  # the `name` and `contacts` methods are defined without def syntax.
+  # (Steep can skip checking if the methods are implemented.)
+
+  # @dynamic name, contacts
+  attr_reader :name
+  attr_reader :contacts
+
+  def initialize(name:)
+    @name = name
+    @contacts = []
+  end
+
+  def guess_country()
+    contacts.map do |contact|
+      # With case expression, simple type-case is implemented.
+      # `contact` has type of `Phone | Email` but in the `when` clause, contact has type of `Phone`.
+      case contact
+      when Phone
+        contact.country
+      end
+    end.compact.first
+  end
+end
+
+class Email
+  # @dynamic address
+  attr_reader :address
+
+  def initialize(address:)
+    @address = address
+  end
+
+  def ==(other)
+    # `other` has type of `any`, which means type checking is skipped.
+    # No type errors can be detected in this method.
+    other.is_a?(self.class) && other.address == address
+  end
+
+  def hash
+    self.class.hash ^ address.hash
+  end
+end
+
+class Phone
+  # @dynamic country, number
+  attr_reader :country, :number
+
+  def initialize(country:, number:)
+    @country = country
+    @number = number
+  end
+
+  def ==(other)
+    # You cannot use `case` for type case because `other` has type of `any`, not a union type.
+    # You have to explicitly declare the type of `other` in `if` expression.
+
+    if other.is_a?(Phone)
+      # @type var other: Phone
+      other.country == country && other.number == number
+    end
+  end
+
+  def hash
+    self.class.hash ^ country.hash ^ number.hash
+  end
+end

data/example/sample2/sig/2.rbi

@@ -0,0 +1,25 @@
+class Person
+  @name: String
+  @contacts: Array<Email | Phone>
+
+  def initialize: (name: String) -> any
+  def name: -> String
+  def contacts: -> Array<Email | Phone>
+  def guess_country: -> (String | nil)
+end
+
+class Email
+  @address: String
+
+  def initialize: (address: String) -> any
+  def address: -> String
+end
+
+class Phone
+  @country: String
+  @number: String
+
+  def initialize: (country: String, number: String) -> any
+  def country: -> String
+  def number: -> String
+end

data/exe/yard2steep

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "yard2steep"
+
+Yard2steep::CLI.run!(ARGV)

data/lib/yard2steep/ast/class_node.rb

@@ -0,0 +1,95 @@
+module Yard2steep
+  module AST
+    # AST::ClassNode represents `Class` or `Module` AST.
+    class ClassNode
+      # @return [AST::ClassNode]
+      def self.create_main
+        AST::ClassNode.new(
+          kind:   'module',
+          c_name: 'main',
+          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
+
+      KIND = ['class', 'module']
+
+      # @param [String] kind
+      # @param [String] c_name
+      # @param [AST::ClassNode | nil] parent
+      def initialize(kind:, c_name:, parent:)
+        Util.assert! { KIND.include?(kind) }
+        Util.assert! { c_name.is_a?(String) }
+        Util.assert! {
+          parent.is_a?(AST::ClassNode) ||
+          (parent == nil && c_name == 'main')
+        }
+        @kind      = kind
+        @c_name    = c_name
+        @c_list    = []  # list of constants
+        @m_list    = []  # list of methods
+        @ivar_list = []  # list of instance variables
+        @children  = []  # list of child classes
+        @parent    = parent
+      end
+
+      # @param [AST::ConstantNode] c
+      # @return [void]
+      def append_constant(c)
+        @c_list.push(c)
+      end
+
+      # @param [AST::MethodNode] m
+      # @return [void]
+      def append_m(m)
+        @m_list.push(m)
+      end
+
+      # @param [AST::IVarNode] ivar
+      # @return [void]
+      def append_ivar(ivar)
+        @ivar_list.push(ivar)
+      end
+
+      # @param [AST::ClassNode] child
+      # @return [void]
+      def append_child(child)
+        @children.push(child)
+      end
+
+      # @return [String]
+      def long_name
+        @long_name ||= begin
+           # NOTE: main has no long_name
+           if @c_name == 'main'
+             ''
+           elsif @parent.c_name == 'main'
+             @c_name
+           else
+             "#{@parent.long_name}::#{@c_name}"
+           end
+        end
+      end
+
+      # @return [String]
+      def to_s
+        inspect
+      end
+
+      # @return [String]
+      def inspect
+        <<-EOF
+{
+  #{@kind}: #{c_name},
+  c_list: [#{@c_list.map(&:to_s).map { |s| "#{s}\n" }.join}],
+  m_list: [#{@m_list.map(&:to_s).map { |s| "#{s}\n" }.join}],
+  ivar_list: [#{@ivar_list.map(&:to_s).map { |s| "#{s}\n" }.join}],
+  children: [#{@children.map(&:to_s).map { |s| "#{s}\n" }.join}],
+}
+        EOF
+      end
+    end
+  end
+end

data/lib/yard2steep/ast/constant_node.rb

@@ -0,0 +1,21 @@
+module Yard2steep
+  module AST
+    class ConstantNode
+      # @dynamic name, klass
+      attr_reader :name, :klass
+
+      # @param [String] name
+      # @param [String] klass
+      def initialize(name:, klass:)
+        Util.assert! { name.is_a?(String) }
+        @name  = name
+        @klass = klass
+      end
+
+      # @return [String]
+      def long_name
+        "#{@klass.long_name}::#{@name}"
+      end
+    end
+  end
+end

data/lib/yard2steep/ast/i_var_node.rb

@@ -0,0 +1,15 @@
+module Yard2steep
+  module AST
+    # IVarNode represents `instance variable` AST.
+    class IVarNode
+      # @dynamic name
+      attr_reader :name
+
+      # @param [String] name
+      def initialize(name:)
+        Util.assert! { name.is_a?(String) }
+        @name = name
+      end
+    end
+  end
+end