orthoses 1.7.0 → 1.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e2915ad2b524676ac4ea67e61fcc90713bdaa8e79cb2ff01aeba74fe54b4885d
-  data.tar.gz: 0f8823a7e88b4030eb6554ac9f35a068730ac944378832f923c99cf3b4e8e6be
+  metadata.gz: dd4d2682b08812b2f8fa633aa299702d38fd509439e4e2ac0b8751a64358b32a
+  data.tar.gz: 28118eed7d772c490670f83277ccdabc4d2938ca329f5051f8aebd40be1f08a6
 SHA512:
-  metadata.gz: '06038e9dd28433a1c9358915720fe942f597caee2d68651ce7c54b47136633cc1d55288c7b8053766f393bacda9974b1ee662337f80d78b0796d405453b2cc32'
-  data.tar.gz: 92074fd8665515453126f44627604f7fd3da1dcb7a85ec25b1ef51424c6797f9b1f67925d2349db05b7ce7aace06dc7f3f2d2be737cfb5399383bed4f846b11f
+  metadata.gz: 1f4262320cb3d9ef5304cbdb53af7cb0e0895bac03e7d98697cf38fc73dabc25b579c6fd4a213ae5c0d97d1763f88dabde2f7f1e6455a084c424ef6b042a3acb
+  data.tar.gz: 35e2b8378b602ad6b853ba7f543d807aab514d0f2a7d8b931230912084d40c7222e45d09cfe4b3eddd614f62bcce578cac2b6e14dac08f5578089ecbb7d7895c

data/README.md

@@ -29,11 +29,13 @@ For example, You can write script in Rakefile.
 require 'orthoses'
 
 namespace :rbs do
-  desc "build RBS to sig/out"
+  desc "build RBS to sig/orthoses"
   task :build do
     Orthoses::Builder.new do
       use Orthoses::CreateFileByName,
-        base_dir: Rails.root.join("sig/out"),
+        depth: 1,
+        to: "sig/orthoses",
+        rmtree: true,
         header: "# !!! GENERATED CODE !!!"
       use Orthoses::Filter do |name, _content|
         path, _lineno = Object.const_source_location(name)
@@ -53,7 +55,7 @@ namespace :rbs do
 end
 ```
 
-Then, you can see the result files under `sig/out`.
+Then, you can see the result files under `sig/orthoses`.
 
 ## Utils
 
@@ -177,6 +179,11 @@ Sort signatures by class/module.
 
 Trace the argument and return value objects when the method is actually called and determine the type.
 
+## Orthoses::MissingName
+
+Completes undefined class/module names.
+If it is unknown whether it is a class or a module, it is defined as an empty module, and if it is a superclass, it is defined as an empty class.
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/lib/orthoses/attribute.rb

@@ -1,98 +1,71 @@
 module Orthoses
   class Attribute
+    CALL_GRAPH = {}
+
     module Hook
       def attr(*names)
+        (CALL_GRAPH[self]||=[]) << [:attr, names]
         super
       end
 
       def attr_accessor(*names)
+        (CALL_GRAPH[self]||=[]) << [:attr_accessor, names]
         super
       end
 
       def attr_reader(*names)
+        (CALL_GRAPH[self]||=[]) << [:attr_reader, names]
         super
       end
 
       def attr_writer(*names)
+        (CALL_GRAPH[self]||=[]) << [:attr_writer, names]
         super
       end
     end
 
     def initialize(loader)
+      CALL_GRAPH.clear
       @loader = loader
     end
 
     def call
       ::Module.prepend(Hook)
 
-      attr = CallTracer.new
-      attr_accessor = CallTracer.new
-      attr_reader = CallTracer.new
-      attr_writer = CallTracer.new
-
-      store = attr.trace(Hook.instance_method(:attr)) do
-        attr_accessor.trace(Hook.instance_method(:attr_accessor)) do
-          attr_reader.trace(Hook.instance_method(:attr_reader)) do
-            attr_writer.trace(Hook.instance_method(:attr_writer)) do
-              @loader.call
-            end
-          end
-        end
-      end
+      store = @loader.call
 
-      attr.captures.each do |capture|
-        m = capture.method.receiver.to_s.match(/#<Class:([\w:]+)>/)
+      CALL_GRAPH.dup.each do |base_mod, calls|
+        m = base_mod.to_s.match(/#<Class:([\w:]+)>/)
         if m && m[1]
           receiver_name = m[1]
           prefix = "self."
         else
-          receiver_name = Utils.module_name(capture.method.receiver) or next
+          receiver_name = Utils.module_name(base_mod) or next
           prefix = nil
         end
         content = store[receiver_name]
-        names = capture.argument[:names]
-        if names[1].equal?(true)
-          content << "attr_accessor #{prefix}#{names[0]}: untyped"
-        elsif names[1].equal?(false)
-          content << "attr_reader #{prefix}#{names[0]}: untyped"
-        else
-          names.each do |name|
-            content << "attr_reader #{prefix}#{name}: untyped"
+
+        calls.each do |(a, names)|
+          case a
+          when :attr
+            if names[1].equal?(true)
+              content << "attr_accessor #{prefix}#{names[0]}: untyped"
+            elsif names[1].equal?(false)
+              content << "attr_reader #{prefix}#{names[0]}: untyped"
+            else
+              names.each do |name|
+                content << "attr_reader #{prefix}#{name}: untyped"
+              end
+            end
+          else
+            names.each do |name|
+              content << "#{a} #{prefix}#{name}: untyped"
+            end
           end
         end
       end
 
-      each_definition(attr_accessor) do |receiver_name, name|
-        store[receiver_name] << "attr_accessor #{name}: untyped"
-      end
-      each_definition(attr_reader) do |receiver_name, name|
-        store[receiver_name] << "attr_reader #{name}: untyped"
-      end
-      each_definition(attr_writer) do |receiver_name, name|
-        store[receiver_name] << "attr_writer #{name}: untyped"
-      end
-
       store
     end
-
-    private
-
-    def each_definition(call_tracer)
-      call_tracer.captures.each do |capture|
-        m = capture.method.receiver.to_s.match(/#<Class:([\w:]+)>/)
-        names = capture.argument[:names]
-        if m && m[1]
-          receiver_name = m[1]
-          names.each do |name|
-            yield [receiver_name, "self.#{name}"]
-          end
-        else
-          receiver_name = Utils.module_name(capture.method.receiver) or next
-          names.each do |name|
-            yield [receiver_name, name]
-          end
-        end
-      end
-    end
   end
 end

data/lib/orthoses/builder.rb

@@ -13,7 +13,7 @@ module Orthoses
   class Builder
     def initialize(&block)
       @use = []
-      @run = nil
+      @runner = nil
       instance_eval(&block) if block
     end
 
@@ -37,7 +37,11 @@ module Orthoses
 
     def run(loader)
       use Store
-      @run = proc do
+      reset_runner(loader)
+    end
+
+    def reset_runner(loader)
+      @runner = proc do
         Orthoses.logger.info("[loader].call start")
         loader.call.tap do
           Orthoses.logger.info("[loader].call end")
@@ -46,7 +50,7 @@ module Orthoses
     end
 
     def to_loader
-      @use.reverse.inject(@run) { |current, next_proc| next_proc[current] }
+      @use.reverse.inject(@runner) { |current, next_proc| next_proc[current] }
     end
 
     def call

data/lib/orthoses/constant.rb

@@ -14,7 +14,6 @@ module Orthoses
       @loader.call.tap do |store|
         will_add_key_and_content = []
         store.each do |name, _|
-          next if name == :Module
           next if name.start_with?('#<')
 
           begin

data/lib/orthoses/content/duplication_checker.rb

@@ -4,71 +4,103 @@ module Orthoses
     class DuplicationChecker
       def initialize(decl, env: nil)
         @decl = decl
-        @env = env || Utils.rbs_environment
+        @known_env = env || Utils.rbs_environment
+        @builder = RBS::DefinitionBuilder.new(env: @known_env)
+        @uniq_map = {}
       end
 
       def update_decl
         return unless @decl.respond_to?(:members)
 
-        uniq_map = uniq_members
-        drop_set_method_definition(uniq_map)
-        drop_known_method_definition(uniq_map)
+        uniq_members
+        drop_set_method_definition
+        drop_by_singleton_instance
+        drop_known_method_definition
+        drop_known_const_definition
 
-        @decl.members.replace(uniq_map.values)
+        @decl.members.replace(@uniq_map.values)
+
+        @uniq_map.clear
       end
 
       private
 
       def uniq_members
-        {}.tap do |uniq_map|
-          @decl.members.each do |member|
-            if member.instance_of?(RBS::AST::Members::MethodDefinition) && member.overloading?
-              # avoid to duplicate and keep order
-              uniq_map[Object.new] = member
-            else
-              key = member_key(member)
-              drop_member = uniq_map[key]
-              uniq_map[key] = member
-              if drop_member
-                Orthoses.logger.info("#{@decl.name} \"#{member.location.source}\" was droped since duplication")
-              end
+        @decl.members.each do |member|
+          if member.instance_of?(RBS::AST::Members::MethodDefinition) && member.overloading?
+            # avoid to duplicate and keep order
+            @uniq_map[Object.new] = member
+          else
+            key = member_key(member)
+            drop_member = @uniq_map[key]
+            @uniq_map[key] = member
+            if drop_member
+              Orthoses.logger.info("#{@decl.name} \"#{member.location.source}\" was droped since duplication")
             end
           end
         end
       end
 
-      def drop_set_method_definition(uniq_map)
-        attr_accessors = uniq_map.values.grep(RBS::AST::Members::AttrAccessor)
+      def drop_by_singleton_instance
+        singleton_instances = @uniq_map.values.select { |v| v.instance_of?(RBS::AST::Members::MethodDefinition) && v.kind == :singleton_instance }
+        singleton_instances.each do |member|
+          @uniq_map.delete([member.class, member.name, :instance])
+          @uniq_map.delete([member.class, member.name, :singleton])
+        end
+      end
+
+      def drop_set_method_definition
+        attr_accessors = @uniq_map.values.grep(RBS::AST::Members::AttrAccessor)
         attr_accessors.each do |member|
-          uniq_map.delete([RBS::AST::Members::MethodDefinition, :"#{member.name}=", member.kind])
+          @uniq_map.delete([RBS::AST::Members::MethodDefinition, :"#{member.name}=", member.kind])
         end
       end
 
-      def drop_known_method_definition(uniq_map)
+      def drop_known_method_definition
         decl_name = @decl.name.absolute!
-        if m_entry = @env.class_decls[decl_name]
+        if m_entry = @known_env.class_decls[decl_name]
           m_entry.decls.each do |d|
-            d.decl.members.each do |member|
-              case member
-              when RBS::AST::Members::LocationOnly
-                # ignore
-              when RBS::AST::Members::AttrAccessor
-                uniq_map.delete([RBS::AST::Members::MethodDefinition, member.name, member.kind])
-                uniq_map.delete([RBS::AST::Members::MethodDefinition, :"#{member.name}=", member.kind])
-              else
-                uniq_map.delete(member_key(member))
-              end
+            drop_known_method_definition_recur(d)
+          end
+        end
+      end
+
+      def drop_known_method_definition_recur(d)
+        d.decl.members.each do |member|
+          case member
+          when RBS::AST::Members::MethodDefinition
+            if member.kind == :singleton_instance
+              @uniq_map.delete([member.class, member.name, :instance])
+              @uniq_map.delete([member.class, member.name, :singleton])
+            end
+            @uniq_map.delete(member_key(member))
+          when RBS::AST::Members::LocationOnly
+            # ignore
+          when RBS::AST::Members::AttrAccessor
+            @uniq_map.delete([RBS::AST::Members::MethodDefinition, member.name, member.kind])
+            @uniq_map.delete([RBS::AST::Members::MethodDefinition, :"#{member.name}=", member.kind])
+          when RBS::AST::Members::Include
+            if member.name.interface?
+              # If interface is included, it is shared in the same namespace.
+              drop_known_method_definition_recur(@known_env.interface_decls[member.name])
+            else
+              @uniq_map.delete(member_key(member))
             end
+          else
+            @uniq_map.delete(member_key(member))
           end
         end
+      end
 
-        constants_in_uniq_map = uniq_map.select do |key, value|
+      def drop_known_const_definition
+        decl_name = @decl.name.absolute!
+        constants_in_uniq_map = @uniq_map.select do |key, value|
           value.kind_of?(RBS::AST::Declarations::Constant)
         end
         constants_in_uniq_map.each do |key, value|
           type_name = decl_name + value.name
-          if @env.constant_decls[type_name]
-            uniq_map.delete(key)
+          if @known_env.constant_decls[type_name]
+            @uniq_map.delete(key)
           end
         end
       end

data/lib/orthoses/content/environment.rb

@@ -42,7 +42,7 @@ module Orthoses
       def write_to(store:)
         each do |add_content|
           content = store[add_content.name]
-          content.header ||= add_content.header
+          content.header = add_content.header
           content.comment ||= add_content.comment
           content.concat(add_content.body)
         end

data/lib/orthoses/content.rb

@@ -102,19 +102,7 @@ module Orthoses
 
       case val
       when Class
-        superclass =
-          if val.superclass && val.superclass != Object
-            super_module_name = Utils.module_name(val.superclass)
-
-            if super_module_name && super_module_name != "Random::Base" # https://github.com/ruby/rbs/pull/977
-              " < ::#{super_module_name}#{temporary_type_params(super_module_name)}"
-            else
-              nil
-            end
-          else
-            nil
-          end
-        self.header = "class #{Utils.module_name(val)}#{type_params(name)}#{superclass}"
+        self.header = "class #{Utils.module_name(val)}#{type_params(name)}#{build_super_class(val)}"
       when Module
         self.header = "module #{Utils.module_name(val)}#{type_params(name)}"
       else
@@ -124,6 +112,25 @@ module Orthoses
 
     private
 
+    def build_super_class(val)
+      return nil unless val.superclass && val.superclass != Object
+
+      begin
+        # check private const
+        eval(val.superclass.to_s)
+      rescue NameError
+        return nil
+      end
+
+      super_module_name = Utils.module_name(val.superclass)
+      return nil unless super_module_name
+
+      # https://github.com/ruby/rbs/pull/977
+      return nil unless super_module_name != "Random::Base"
+
+      " < ::#{super_module_name}#{temporary_type_params(super_module_name)}"
+    end
+
     class ArrayIO
       def initialize
         @outs = []

data/lib/orthoses/create_file_by_name.rb

@@ -6,31 +6,62 @@ module Orthoses
   class CreateFileByName
     prepend Outputable
 
-    def initialize(loader, base_dir:, header: nil, if: nil)
+    def initialize(loader, base_dir: nil, to: nil, header: nil, if: nil, depth: nil, rmtree: false)
+      unless base_dir.nil?
+        warn "[Orthoses::CreateFileByName] base_dir: option is deprecated. Please use to: option instead."
+      end
+
+      to = to || base_dir
+      unless to
+        raise ArgumentError, "should set to: option"
+      end
+
+      relative_path_from_pwd = Pathname(to).expand_path.relative_path_from(Pathname.pwd).to_s
+      unless relative_path_from_pwd == "." || !relative_path_from_pwd.match?(%r{\A[/\.]})
+        raise ArgumentError, "to=\"#{to}\" should be under current dir=\"#{Pathname.pwd}\"."
+      end
+
       @loader = loader
-      @base_dir = base_dir
+      @to = to
       @header = header
+      @depth = depth
+      @rmtree = rmtree
       @if = binding.local_variable_get(:if)
     end
 
     using Utils::Underscore
 
     def call
+      if @rmtree
+        Orthoses.logger.debug("Remove dir #{@to} since `rmtree: true`")
+        Pathname(@to).rmtree rescue nil
+      end
+
       store = @loader.call
 
-      store.each do |name, content|
-        next unless @if.nil? || @if.call(name, content)
+      store.select! do |name, content|
+        @if.nil? || @if.call(name, content)
+      end
+      grouped = store.group_by do |name, _|
+        splitted = name.to_s.split('::')
+        (@depth ? splitted[0, @depth] : splitted).join('::')
+      end
 
-        file_path = Pathname("#{@base_dir}/#{name.to_s.split('::').map(&:underscore).join('/')}.rbs")
+      grouped.each do |group_name, group|
+        file_path = Pathname("#{@to}/#{group_name.split('::').map(&:underscore).join('/')}.rbs")
         file_path.dirname.mkpath
         file_path.open('w+') do |out|
           if @header
             out.puts @header
             out.puts
           end
-          out.puts content.to_rbs
+          group.sort!
+          contents = group.map do |(name, content)|
+            content.to_rbs
+          end.join("\n")
+          out.puts contents
+          Orthoses.logger.info("Generate file to #{file_path.to_s}")
         end
-        Orthoses.logger.info("Generate file to #{file_path.to_s}")
       end
     end
   end

data/lib/orthoses/lazy_trace_point.rb

@@ -10,32 +10,44 @@ module Orthoses
   #     ...
   #   end
   class LazyTracePoint < TracePoint
+    METHOD_METHOD = ::Kernel.instance_method(:method)
+    INSTANCE_METHOD_METHOD = ::Module.instance_method(:instance_method)
+    UNBOUND_NAME_METHOD = ::Module.instance_method(:name)
+    METHOD_ADDED_HOOKS = {}
+    SINGLETON_METHOD_ADDED_HOOKS = {}
+
     # for TracePoint target
-    ::Module.prepend(Module.new{
+    module MethodAddedHook
       def method_added(id)
+        begin
+          if h = METHOD_ADDED_HOOKS[id]
+            if mod_name = UNBOUND_NAME_METHOD.bind(self).call
+              h[mod_name]&.call(self, id)
+            end
+          end
+        rescue TypeError => e
+        end
         super
       end
-    })
-    ::BasicObject.prepend(Module.new{
+    end
+    ::Module.prepend MethodAddedHook
+
+    module SignletonMethodAddedHook
       def singleton_method_added(id)
+        begin
+          if h = SINGLETON_METHOD_ADDED_HOOKS[id]
+            if mod_name = UNBOUND_NAME_METHOD.bind(self).call
+              h[mod_name]&.call(self, id)
+            end
+          end
+        rescue TypeError => e
+        end
         super
       end
-    })
-
-    METHOD_METHOD = ::Kernel.instance_method(:method)
-    INSTANCE_METHOD_METHOD = ::Module.instance_method(:instance_method)
-    UNBOUND_NAME_METHOD = ::Module.instance_method(:name)
-    METHOD_ADDED_METHOD = ::Module.instance_method(:method_added)
-    SINGLETON_METHOD_ADDED_METHOD = ::BasicObject.instance_method(:singleton_method_added)
-
-    def initialize(*events, &block)
-      @mod_name = nil
-      @instance_method_id = nil
-      @singleton_method_id = nil
-      super
     end
+    ::BasicObject.prepend SignletonMethodAddedHook
 
-    def enable(target: nil, target_line: nil, target_thread: nil, &block)
+    def enable(target: nil, &block)
       return super unless target.kind_of?(String)
 
       case
@@ -59,43 +71,25 @@ module Orthoses
     private
 
     def trace_instance_method(&block)
-      # try to load
       target = Object.const_get(@mod_name).instance_method(@instance_method_id)
       enable(target: target, &block)
     rescue NameError
-      TracePoint.new(:call) do |tp|
-        id = tp.binding.local_variable_get(:id)
-        next unless id == @instance_method_id
-
-        mod_name = UNBOUND_NAME_METHOD.bind(tp.self).call
-
-        next unless mod_name
-        next unless mod_name == @mod_name
-
-        enable(target: INSTANCE_METHOD_METHOD.bind(tp.self).call(id))
-        tp.disable
-      end.enable(target: METHOD_ADDED_METHOD, &block)
+      (METHOD_ADDED_HOOKS[@instance_method_id] ||= {})[@mod_name] = ->(const, id) {
+        enable(target: INSTANCE_METHOD_METHOD.bind(const).call(id))
+      }
+      block&.call
     ensure
       disable
     end
 
     def trace_singleton_method(&block)
-      # try to load
       target = Object.const_get(@mod_name).method(@singleton_method_id)
       enable(target: target, &block)
     rescue NameError
-      TracePoint.new(:call) do |tp|
-        id = tp.binding.local_variable_get(:id)
-        next unless id == @singleton_method_id
-
-        mod_name = UNBOUND_NAME_METHOD.bind(tp.self).call
-
-        next unless mod_name
-        next unless mod_name == @mod_name
-
-        enable(target: METHOD_METHOD.bind(tp.self).call(id))
-        tp.disable
-      end.enable(target: SINGLETON_METHOD_ADDED_METHOD, &block)
+      (SINGLETON_METHOD_ADDED_HOOKS[@singleton_method_id] ||= {})[@mod_name] = ->(const, id) {
+        enable(target: METHOD_METHOD.bind(const).call(id))
+      }
+      block&.call
     ensure
       disable
     end

data/lib/orthoses/missing_name.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Orthoses
+  class MissingName
+    def initialize(loader)
+      @loader = loader
+    end
+
+    def call
+      @loader.call.tap do |store|
+        MissingClass.new(store).call
+        MissingModule.new(store).call
+      end
+    end
+
+    private
+
+    class MissingClass
+      def initialize(store)
+        @store = store
+      end
+
+      def call
+        @store.values.each do |content|
+          recur(content)
+        end
+      end
+
+      private
+
+      def recur(content)
+        content.auto_header
+        if content.header && content.header.include?("<")
+          _, superclass = content.header.split(/\s*<\s*/, 2)
+          superclass.sub!(/\[.*/, "")
+          new_name = TypeName(superclass).relative!.to_s
+          recur(@store[new_name])
+        end
+      end
+    end
+
+    class MissingModule
+      def initialize(store)
+        @store = store
+      end
+
+      def call
+        missings = []
+        @store.keys.each do |key_name|
+          missings.concat split_name(key_name)
+        end
+        missings.uniq!
+        missings.each do |missing|
+          @store[missing].header = "module #{missing}"
+        end
+      end
+
+      private
+
+      def split_name(key_name)
+        ret = []
+
+        type_name = TypeName(key_name).relative!
+        if !Utils.rbs_defined_class?(type_name.to_s) && !@store.has_key?(type_name.to_s)
+          ret << type_name.to_s
+        end
+
+        path = type_name.namespace.path
+        path.each_with_index do |sym, index|
+          name = path[0, index + 1].join("::")
+          next if name.empty?
+          if !Utils.rbs_defined_class?(name) && !@store.has_key?(name)
+            ret << name
+          end
+        end
+
+        ret
+      end
+    end
+  end
+end