rbs-dynamic 0.1.0

data/lib/rbs/dynamic/builder/types.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+require "rbs"
+# require_relative "./../refine/signature_merger.rb"
+
+module RBS module Dynamic module Builder
+  class Types
+    BOOL = RBS::Types::Bases::Bool.new(location: nil)
+    VOID = RBS::Types::Bases::Void.new(location: nil)
+    ANY  = RBS::Types::Bases::Any.new(location: nil)
+
+    module ToRBSType
+      refine Object do
+        def to_rbs_type
+          { type: self, args: [] }
+        end
+      end
+
+      refine Hash do
+        def to_rbs_type
+          self
+        end
+      end
+    end
+    using ToRBSType
+
+    module RBSTypeMerger
+      refine Object do
+        def merge_type(*)
+          nil
+        end
+      end
+
+      refine Hash do
+        def merge_type(other)
+          return unless Hash === other
+          return unless self[:type] == other[:type]
+          return unless self[:args].count == other[:args].count
+          { type: self[:type], value: [self[:value], other[:value]].flatten.compact.uniq, args: self[:args].zip(other[:args]).map(&:flatten).map(&:uniq) }
+        end
+      end
+
+      refine Array do
+        def push_merge_type(other)
+          each.with_index { |type, i|
+            merged = type.merge_type(other)
+            if merged
+              self[i] = merged
+              return self
+            end
+          }
+          push(other)
+        end
+
+        def zip_type
+          inject([]) { |result, type|
+            result.push_merge_type(type)
+          }
+        end
+      end
+    end
+    using RBSTypeMerger
+
+    using Module.new {
+      refine Object do
+        def type(*)
+          RBS::Types::Literal.new(
+            literal: self,
+            location: nil
+          )
+        end
+      end
+
+      refine Class do
+        def type(*args)
+          RBS::Types::ClassInstance.new(
+            args: args.map { Array === _1 && _1.empty? ? ANY : Types.new(_1).build },
+            location: nil,
+            name: name
+          )
+        end
+      end
+
+      refine NilClass do
+        def type(*)
+          RBS::Types::Bases::Nil.new(location: nil)
+        end
+      end
+
+      refine Hash do
+        def type
+          self[:type].type(*self[:args])
+        end
+      end
+
+      refine RBS::Types::Bases::Base do
+        def |(other)
+          RBS::Types::Union.new(
+            types: [self, other],
+            location: nil
+          )
+        end
+
+        def type
+          self
+        end
+      end
+
+      refine RBS::Types::Literal do
+        def |(other)
+          RBS::Types::Union.new(
+            types: [self, other],
+            location: nil
+          )
+        end
+      end
+
+      refine RBS::Types::Application do
+        def type(*)
+          self
+        end
+
+        def |(other)
+          RBS::Types::Union.new(
+            types: [self, other],
+            location: nil
+          )
+        end
+      end
+
+      refine RBS::Types::Union do
+        def |(other)
+          RBS::Types::Union.new(
+            types: (types + [other]),
+            location: nil
+          )
+        end
+      end
+
+      refine Array do
+        def union_type
+          map { _1.type }.inject { _1 | _2 }
+        end
+      end
+    }
+
+    attr_reader :types
+
+    def initialize(type)
+      @types = case type
+               when nil
+                 [nil]
+               when Hash
+                 [type]
+               else
+                 Array(type)
+               end.map(&:to_rbs_type).uniq.zip_type
+    end
+
+    def build
+      if optional?
+        RBS::Types::Optional.new(
+          type: (target_types - [NIL_RBS_TYPE, NILCLASS_RBS_TYPE]).union_type,
+          location: nil
+        )
+      else
+        target_types.union_type
+      end
+    end
+
+    NILCLASS_RBS_TYPE = NilClass.to_rbs_type
+    NIL_RBS_TYPE = nil.to_rbs_type
+
+    TRUECLASS_RBS_TYPE = TrueClass.to_rbs_type
+    TRUE_RBS_TYPE = true.to_rbs_type
+
+    FALSECLASS_RBS_TYPE = FalseClass.to_rbs_type
+    FALSE_RBS_TYPE = false.to_rbs_type
+
+    def optional?
+      !!types.group_by { _1 == NIL_RBS_TYPE || _1 == NILCLASS_RBS_TYPE }.values.then { |opt, other| opt&.size&.>=(1) && other&.size&.>=(1) }
+    end
+
+    def in_bool?
+      0 < types.count { _1 == TRUE_RBS_TYPE || _1 == TRUECLASS_RBS_TYPE } && 0 < types.count { _1 == FALSE_RBS_TYPE || _1 == FALSECLASS_RBS_TYPE }
+    end
+
+    def target_types
+      (types + types.flat_map { Array(_1[:value]).map { |value| { type: value, args: [] } } })
+        .tap { break _1 - [NIL_RBS_TYPE, NILCLASS_RBS_TYPE] if optional? }
+        .tap { break _1 - [TRUE_RBS_TYPE, TRUECLASS_RBS_TYPE, FALSE_RBS_TYPE, FALSECLASS_RBS_TYPE] + [BOOL] if in_bool? }
+    end
+  end
+end end end

data/lib/rbs/dynamic/builder.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+require "rbs"
+require_relative "./builder/types.rb"
+require_relative "./builder/methods.rb"
+
+module RBS module Dynamic module Builder
+  class Base
+    attr_reader :interface_members
+
+    def initialize
+      @inclued_modules = []
+      @prepended_modules = []
+      @extended_modules = []
+      @constant_variables = Hash.new { |h, name| h[name] = [] }
+      @instance_variables = Hash.new { |h, name| h[name] = [] }
+      @methods = Hash.new { |h, name| h[name] = Methods.new(name, kind: :instance) }
+      @singleton_methods = Hash.new { |h, name| h[name] = Methods.new(name, kind: :singleton) }
+      @other_members = []
+      @interface_members = []
+    end
+
+    def add_inclued_module(mod)
+      @inclued_modules << mod
+    end
+
+    def add_prepended_module(mod)
+      @prepended_modules << mod
+    end
+
+    def add_extended_module(mod)
+      @extended_modules << mod
+    end
+
+    def add_constant_variable(name, type)
+      @constant_variables[name] << type
+    end
+
+    def add_instance_variable(name, type)
+      @instance_variables[name] << type
+    end
+
+    def add_singleton_method(name, sig)
+      @singleton_methods[name] << sig
+    end
+
+    def add_method(name, sig = {})
+      @methods[name] << sig
+    end
+
+    def add_member(member)
+      @other_members << member
+    end
+
+    def add_interface_members(member)
+      @interface_members << member
+    end
+
+    def build_members
+      [
+        *build_inclued_modules,
+        *build_prepended_modules,
+        *build_extended_modules,
+        *build_constant_variables,
+        *build_singleton_methods,
+        *build_methods,
+        *build_instance_variables,
+        *@interface_members.map(&:build),
+        *@other_members
+      ]
+    end
+
+    def build_inclued_modules
+      @inclued_modules.map { |mod|
+        RBS::AST::Members::Include.new(
+          name: mod.name,
+          args: [],
+          annotations: [],
+          location: nil,
+          comment: nil
+        )
+      }
+    end
+
+    def build_prepended_modules
+      @prepended_modules.map { |mod|
+        RBS::AST::Members::Prepend.new(
+          name: mod.name,
+          args: [],
+          annotations: [],
+          location: nil,
+          comment: nil
+        )
+      }
+    end
+
+    def build_extended_modules
+      @extended_modules.map { |mod|
+        RBS::AST::Members::Extend.new(
+          name: mod.name,
+          args: [],
+          annotations: [],
+          location: nil,
+          comment: nil
+        )
+      }
+    end
+
+    def build_constant_variables
+      @constant_variables.map { |name, types|
+        RBS::AST::Members::InstanceVariable.new(
+          name: name,
+          type: Types.new(types.flatten).build,
+          location: nil,
+          comment: nil
+        )
+      }
+    end
+
+    def build_instance_variables
+      @instance_variables.map { |name, types|
+        RBS::AST::Declarations::Constant.new(
+          name: name,
+          type: Types.new(types.flatten).build,
+          location: nil,
+          comment: nil
+        )
+      }
+    end
+
+    def build_singleton_methods
+      @singleton_methods.values.map(&:build)
+    end
+
+    def build_methods
+      @methods.values.map(&:build)
+    end
+  end
+  private_constant :Base
+
+  class Module < Base
+    attr_reader :module
+
+    def initialize(module_)
+      super()
+      @module = module_
+    end
+
+    def build
+      RBS::AST::Declarations::Module.new(
+        name: self.module.name,
+        type_params: [],
+        self_types: [],
+        members: build_members,
+        location: nil,
+        annotations: [],
+        comment: nil
+      )
+    end
+  end
+
+  class Class < Base
+    attr_reader :klass
+
+    def initialize(klass)
+      super()
+      @klass = klass
+    end
+
+    def build
+      RBS::AST::Declarations::Class.new(
+        name: klass.name,
+        type_params: [],
+        super_class: build_super_class,
+        members: build_members,
+        location: nil,
+        annotations: [],
+        comment: nil
+      )
+    end
+
+    def build_super_class
+      ::RBS::AST::Declarations::Class::Super.new(
+        name: klass.superclass.name,
+        args: [],
+        location: nil
+      ) unless klass.superclass&.name.nil? || Object == klass.superclass
+    end
+  end
+
+  class Interface < Base
+    attr_reader :name
+    attr_reader :methods
+
+    def initialize(name)
+      super()
+      @name = name
+    end
+
+    def build
+      RBS::AST::Declarations::Interface.new(
+        name: @name,
+        type_params: [],
+        members: build_members,
+        annotations: [],
+        location: nil,
+        comment: nil
+      )
+    end
+
+    def eql?(other)
+      self.methods.map { |_, method| [method.name, method.kind, method.sigs] } ==
+        other.methods.map { |_, method| [method.name, method.kind, method.sigs] }
+    end
+  end
+end end end

data/lib/rbs/dynamic/cli.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+require "thor"
+require_relative "../dynamic.rb"
+
+module RBS module Dynamic
+  class CLI < Thor
+    desc "version", "show version"
+    def version
+      puts "rbs dynamic version #{RBS::Dynamic::VERSION}"
+    end
+
+    desc "trace [filename]", ""
+    option :"root-path", type: :string, default: Dir.pwd, desc: "Rooting path. Default: current dir"
+    option :"target-filepath-pattern", type: :string, default: ".*", desc: "Target filepath pattern. e.g. hoge\\|foo\\|bar. Default '.*'"
+    option :"ignore-filepath-pattern", type: :string, default: nil, desc: "Ignore filepath pattern. Priority over `target-filepath-pattern`. e.g. hoge\\|foo\\|bar. Default ''"
+    option :"target-classname-pattern", type: :string, default: ".*", desc: "Target class name pattern. e.g. RBS::Dynamic. Default '.*'"
+    option :"ignore-classname-pattern", type: :string, default: nil, desc: "Ignore class name pattern. Priority over `target-classname-pattern`. e.g. PP\\|PrettyPrint. Default ''"
+    option :"ignore-class_members", type: :array, enum: %w(inclued_modules prepended_modules extended_modules constant_variables instance_variables singleton_methods methods)
+    option :"method-defined-calsses", type: :array, enum: %w(defined_class receiver_class), desc: "Which class defines method type. Default: defined_class and receiver_class"
+    option :"show-method-location", type: :boolean, default: false, desc: "Show source_location and called_location in method comments. Default: no"
+    option :"use-literal_type", type: :boolean, default: false, desc: "Integer and Symbol as literal types. e.g func(:hoge, 42). Default: no"
+    option :"with-literal_type", type: :boolean, default: false, desc: "Integer and Symbol with literal types. e.g func(Symbol | :hoge | :foo). Default: no"
+    option :"use-interface_method_argument", type: :boolean, default: false, desc: "Define method arguments in interface. Default: no"
+    option :"stdout", type: :boolean, default: false, desc: "stdout at runtime. Default: no"
+    option :"trace-c_api-method", type: :boolean, default: false, desc: "Trace C API method. Default: no"
+    def trace(filename)
+      decls = RBS::Dynamic.trace(**options) {
+        load filename
+      }.values
+      stdout = StringIO.new
+      writer = RBS::Writer.new(out: stdout)
+      writer.write(decls)
+      puts "# RBS dynamic trace #{RBS::Dynamic::VERSION}"
+      puts
+      puts stdout.string
+    end
+  end
+end end

data/lib/rbs/dynamic/config.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module RBS module Dynamic
+  class Config
+    attr_reader :options
+
+    def initialize(options)
+      @options = options
+    end
+
+    def except_build_members
+      ignore_class_members
+    end
+
+    def root_path
+      options["root-path"] || options[:root_path] || Dir.pwd
+    end
+
+    def target_filepath_pattern
+      options["target-filepath-pattern"] || options[:target_filepath_pattern] || /.*/
+    end
+
+    def ignore_filepath_pattern
+      options["ignore-filepath-pattern"] || options[:ignore_filepath_pattern]
+    end
+
+    def target_classname_pattern
+      Regexp.new(options["target-classname-pattern"] || options[:target_classname_pattern] || /.*/)
+    end
+
+    def ignore_classname_pattern
+      (options["ignore-classname-pattern"] || options[:ignore_classname_pattern])&.then { Regexp.new(_1) }
+    end
+
+    def ignore_class_members
+      (options["ignore-class_members"] || options[:ignore_class_members] || []).map(&:to_sym)
+    end
+
+    def method_defined_calssses
+      (options["method-defined-calsses"] || options[:method_defined_calssses] || %i(defined_class receiver_class)).map(&:to_sym)
+    end
+
+    def show_method_location?
+      options["show-method-location"] || options[:show_method_location] || false
+    end
+
+    def use_literal_type?
+      options["use-literal_type"] || options[:use_literal_type] || false
+    end
+
+    def with_literal_type?
+      options["with-literal_type"] || options[:with_literal_type] || false
+    end
+
+    def use_interface_method_argument?
+      options["use-interface_method_argument"] || options[:use_interface_method_argument] || false
+    end
+
+    def trace_c_api_method?
+      options["trace-c_api-method"] || options[:trace_c_api_method] || false
+    end
+
+    def stdout?
+      (options["stdout"] || options[:stdout]).then { _1.nil? ? true : _1 }
+    end
+  end
+end end

data/lib/rbs/dynamic/converter/called_method_to_sigunature.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "rbs"
+require_relative "../refine/trace_point.rb"
+require 'pathname'
+
+module RBS module Dynamic module Converter
+  module CalledMethodToMethodSigunature
+    using RBS::Dynamic::Refine::TracePoint::ToRBSType
+
+    using Module.new {
+      refine String do
+        def relative_path(base_directory)
+          delete_prefix(base_directory)
+        end
+      end
+
+      refine Hash do
+        def except(*keys)
+          slice(*self.keys - keys)
+        end unless method_defined?(:except)
+
+        def value_to_type
+          merge(type: self[:value] || self[:type]).except(:value)
+        end
+
+        def type_to_rbs_type(use_literal_type: false, with_literal_type: false)
+          if use_literal_type
+            merge(type: self[:rbs_type].value_to_type).except(:op, :rbs_type, :value_object_id)
+          elsif with_literal_type
+            merge(type: self[:rbs_type]).except(:op, :rbs_type, :value_object_id)
+          else
+            merge(type: self[:rbs_type].except_value).except(:op, :rbs_type, :value_object_id)
+          end
+        end
+      end
+    }
+
+    refine Array do
+      def type_to_rbs_type(use_literal_type: false, with_literal_type: false)
+        map { _1.type_to_rbs_type(use_literal_type: use_literal_type, with_literal_type: with_literal_type) }
+      end
+    end
+
+    refine Hash do
+      def method_sigunature(root_path: nil, include_location: false, use_literal_type: false, with_literal_type: false)
+        opt = { use_literal_type: use_literal_type, with_literal_type: with_literal_type }
+        visibility = self[:visibility] if self[:visibility] != :public
+
+        req_opt = self[:arguments].take_while { _1[:op] != :rest }.to_a
+        rest, *other = self[:arguments].drop_while { _1[:op] != :rest }.to_a
+        req_opt ||= []
+        rest ||= []
+        {
+          required_positionals: req_opt.select { _1[:op] == :req }.type_to_rbs_type(**opt),
+          optional_positionals: req_opt.select { _1[:op] == :opt }.type_to_rbs_type(**opt),
+          rest_positionals: self[:arguments].select { _1[:op] == :rest }.type_to_rbs_type(**opt),
+          trailing_positionals: other.select { _1[:op] == :req }.type_to_rbs_type(**opt),
+          required_keywords: self[:arguments].select { _1[:op] == :keyreq }.type_to_rbs_type(**opt),
+          optional_keywords: self[:arguments].select { _1[:op] == :key }.type_to_rbs_type(**opt),
+          rest_keywords: self[:arguments].select { _1[:op] == :keyrest }.type_to_rbs_type(**opt),
+          block: self[:block].map { _1.method_sigunature(include_location: false, **opt) },
+          source_location: ("#{self[:path].relative_path(root_path)}:#{self[:lineno]}" if include_location),
+          reference_location: ("#{self[:called_path].relative_path(root_path)}:#{self[:called_lineno]}" if include_location)
+        }.merge(
+          return_type: (if use_literal_type
+                          self[:return_value_rbs_type].value_to_type
+                        elsif with_literal_type
+                          self[:return_value_rbs_type]
+                        else
+                          self[:return_value_rbs_type].except_value
+                        end),
+          visibility: visibility
+        )
+    end
+  end
+end
+end end end

data/lib/rbs/dynamic/converter/called_method_to_with_interface.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'pathname'
+require_relative "./called_method_to_sigunature.rb"
+
+module RBS module Dynamic module Converter
+  module CalledMethodToWithInterface
+    using CalledMethodToMethodSigunature
+    refine Hash do
+      def to_with_interface(defined_interfaces: [])
+        self.dup.then { |called_method|
+          interfaces = called_method[:arguments].each.with_index(1).inject([]) { |interfaces, (argument, i)|
+            called_methods = called_method[:called_methods].select { _1[:receiver_object_id] == argument[:value_object_id] }
+            next interfaces if called_methods.empty?
+
+            interface = RBS::Dynamic::Builder::Interface.new("dummy_name")
+            sub_interfaces = called_methods.map { |called_method|
+              called_method, sub_interfaces = called_method.to_with_interface(defined_interfaces: defined_interfaces + interfaces)
+              # Non support nexted defined interface in RBS
+              # sub_interfaces.map { interface.add_member(_1.build) }
+              interface.add_method(called_method[:method_id], **called_method.method_sigunature)
+              sub_interfaces
+            }.flatten
+            interfaces += sub_interfaces
+
+            unless interface_ = (defined_interfaces + interfaces).find { _1.eql? interface }
+              interface_name = "_Interface_have__#{called_methods.map { _1[:method_id] }.uniq.join("__")}__#{(defined_interfaces + interfaces).count + 1}"
+                                # except #+ #== #hoge? methods
+                                .gsub(/[^[:alnum:]_]/, "")
+              interface.instance_exec { @name = interface_name }
+              interfaces << interface
+            end
+
+            argument[:rbs_type][:type] = RBS::Types::Interface.new(name: (interface_ || interface).name, args: [], location: nil)
+
+            interfaces
+          }
+
+          [called_method, interfaces]
+        }
+      end
+    end
+  end
+end end end