orthoses 0.1.0

data/lib/orthoses/load_rbs.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Orthoses
+  class LoadRBS
+    # use Orthoses::LoadRBS,
+    #   paths: Dir.glob("known_sig/**/*.rbs")
+    def initialize(loader, paths:)
+      @loader = loader
+      @paths = paths
+    end
+
+    def call
+      @loader.call.tap do |store|
+        tmp_env = RBS::Environment.new
+
+        @paths.each do |path|
+          Orthoses.logger.debug("Load #{path}")
+          buffer = RBS::Buffer.new(name: path.to_s, content: File.read(path.to_s, encoding: "UTF-8"))
+          decls = RBS::Parser.parse_signature(buffer)
+          decls.each { |decl| tmp_env << decl }
+        end
+
+        tmp_env.class_decls.each do |type_name, m_entry|
+          name = type_name.relative!.to_s
+          content = store[name]
+          case decl = m_entry.decls.first.decl
+          when RBS::AST::Declarations::Module
+            self_types = decl.self_types.empty? ? nil : " : #{decl.self_types.join(', ')}"
+            content.header = "module #{name_and_params(name, decl.type_params)}#{self_types}"
+          when RBS::AST::Declarations::Class
+            super_class = decl.super_class.nil? ? nil : " < #{name_and_args(decl.super_class.name, decl.super_class.args)}"
+            content.header = "class #{name_and_params(name, decl.type_params)}#{super_class}"
+          end
+          decls_to_lines(m_entry.decls.map(&:decl)).each do |line|
+            content << line
+          end
+        end
+
+        tmp_env.interface_decls.each do |type_name, s_entry|
+          name = type_name.relative!.to_s
+          content = store[name]
+          decl = s_entry.decl
+          content.header = "interface #{name_and_params(name, decl.type_params)}"
+          decls_to_lines([decl]).each do |line|
+            content << line
+          end
+        end
+      end
+    end
+
+    private
+
+    def name_and_params(name, params)
+      if params.empty?
+        "#{name}"
+      else
+        ps = params.each.map do |param|
+          param.to_s
+        end
+
+        "#{name}[#{ps.join(", ")}]"
+      end
+    end
+
+    def name_and_args(name, args)
+      if name && args
+        if args.empty?
+          "#{name}"
+        else
+          "#{name}[#{args.join(", ")}]"
+        end
+      end
+    end
+
+    def decls_to_lines(decls)
+      out = StringIO.new
+      writer = RBS::Writer.new(out: out)
+      decls.each do |decl|
+        if decl.respond_to?(:members)
+          decl.members.each do |member|
+            next if member.respond_to?(:members)
+            writer.write_member(member)
+          end
+        end
+      end
+      out.string.each_line(chomp: true).to_a
+    end
+  end
+end

data/lib/orthoses/object_space_all.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Orthoses
+  class ObjectSpaceAll
+    def initialize(loader, if: nil)
+      @loader = loader
+      @if = binding.local_variable_get(:if)
+    end
+
+    def call
+      store = @loader.call
+
+      after_modules = ObjectSpace.each_object(Module).to_a
+      after_modules.each do |mod|
+        mod_name = Utils.module_name(mod)
+        next if mod_name.nil?
+        next unless @if.nil? || @if.call(mod)
+
+        store[mod_name]
+      end
+
+      store
+    end
+  end
+end

data/lib/orthoses/pp.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Orthoses
+  # Debug current stored values
+  #   use Orthoses::PP
+  class PP
+    def initialize(loader)
+      @loader = loader
+    end
+
+    def call
+      pp @loader.call
+    end
+  end
+end

data/lib/orthoses/store.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Orthoses
+  # Internal middleware for return store object
+  # Builder set this middleware on last stack by default
+  class Store
+    def initialize(loader)
+      @loader = loader
+    end
+
+    def call
+      @loader.call
+      Utils.new_store
+    end
+  end
+end

data/lib/orthoses/tap.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Orthoses
+  # use Orthoses::Tap do |store|
+  #   store["Foo::Bar"] << "def baz: () -> void"
+  # end
+  class Tap
+    def initialize(loader, &block)
+      @loader = loader
+      @block = block
+    end
+
+    def call
+      @loader.call.tap do |store|
+        @block.call(store)
+      end
+    end
+  end
+end

data/lib/orthoses/utils.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+module Orthoses
+  module Utils
+    def self.unautoload!
+      ObjectSpace.each_object(Module) do |mod|
+        each_const_recursive(mod)
+      end
+    end
+
+    def self.each_const_recursive(root, cache: {}, on_error: nil, &block)
+      root.constants(false).each do |const|
+        val = root.const_get(const)
+        next if cache[const].equal?(val)
+        cache[const] = val
+        next if val.equal?(root)
+        block.call(root, const, val) if block
+        if val.respond_to?(:constants)
+          each_const_recursive(val, cache: cache, on_error: on_error, &block)
+        end
+      rescue LoadError, StandardError => err
+        Orthoses.logger.warn("Orthoses::Utils.each_const_recursive: #{err.class}: #{err.message} on #{err.backtrace.first}")
+        if on_error
+          on_error.call(ConstLoadError.new(root: root, const: const, error: err))
+        end
+      end
+    end
+
+    def self.rbs_defined_const?(name, library: nil, collection: false)
+      return false if name.start_with?("#<")
+      env = rbs_environment(library: library, collection: collection)
+      name = name.sub(/Object::/, '')
+      target = rbs_type_name(name)
+      env.constant_decls.has_key?(target)
+    end
+
+    def self.rbs_defined_class?(name, library: nil, collection: false)
+      return false if name.start_with?("#<")
+      env = rbs_environment(library: library, collection: collection)
+      target = rbs_type_name(name)
+      env.class_decls.has_key?(target)
+    end
+
+    def self.rbs_type_name(name)
+      name = "::#{name}" if !name.start_with?("::")
+      RBS::Namespace.parse(name).to_type_name
+    end
+
+    def self.rbs_environment(library: nil, collection: false)
+      @env_cache ||= {}
+      if hit = @env_cache[[library, collection]]
+        return hit
+      end
+
+      loader = RBS::EnvironmentLoader.new
+
+      if collection
+        lock = RBS::Collection::Config::PATH&.then { |p| RBS::Collection::Config.lockfile_of(p) }
+        loader.add_collection(lock) if lock
+      end
+
+      case library
+      when "stdlib"
+        RBS::Repository::DEFAULT_STDLIB_ROOT.each_entry do |path|
+          lib = path.to_s
+          loader.add(library: lib.to_s) unless lib == "." || lib == ".."
+        end
+      else
+        Array(library).each do |lib|
+          loader.add(library: lib.to_s)
+        end
+      end
+
+      environment = RBS::Environment.from_loader(loader).resolve_type_names
+      @env_cache[[library, collection]] = environment
+    end
+
+    def self.object_to_rbs(object, strict:)
+      case object
+      when Class, Module
+        "singleton(#{object})"
+      when Integer, Symbol, String
+        if strict
+          object.inspect
+        else
+          Utils.module_name(object.class) || 'untyped'
+        end
+      when true, false, nil
+        object.inspect
+      when Set
+        if object.empty?
+          "Set[untyped]"
+        else
+          ary = object.map do |o|
+            object_to_rbs(o, strict: strict)
+          end
+          "Set[#{ary.uniq.join(' | ')}]"
+        end
+      when Array
+        if object.empty?
+          "Array[untyped]"
+        else
+          ary = object.map do |o|
+            object_to_rbs(o, strict: strict)
+          end
+          if strict
+            "[#{ary.join(', ')}]"
+          else
+            "Array[#{ary.uniq.join(' | ')}]"
+          end
+        end
+      when Hash
+        if object.empty?
+          "Hash[untyped, untyped]"
+        else
+          if strict && object.keys.all? { |key| key.is_a?(Symbol) && /\A\w+\z/.match?(key) }
+            "{ #{object.map { |k, v| "#{k}: #{object_to_rbs(v, strict: strict)}" }.join(', ')} }"
+          else
+            keys = object.keys.map { |k| object_to_rbs(k, strict: strict) }.uniq
+            values = object.values.map { |k| object_to_rbs(k, strict: strict) }.uniq
+            "Hash[#{keys.join(' | ')}, #{values.join(' | ')}]"
+          end
+        end
+      else
+        Utils.module_name(object.class) || 'untyped'
+      end
+    end
+
+    UNBOUND_NAME_METHOD = Module.instance_method(:name)
+
+    # Want to get the module name even if the method is overwritten.
+    # e.g.) Rails::Info
+    def self.module_name(mod)
+      return nil unless mod
+      UNBOUND_NAME_METHOD.bind(mod).call
+    end
+
+    def self.module_to_type_name(mod)
+      name = Utils.module_name(mod)
+      if name && !name.empty?
+        TypeName(name)
+      else
+        nil
+      end
+    end
+
+    def self.known_type_params(name)
+      type_name =
+        case name
+        when String
+          TypeName(name).absolute!
+        when Module
+          module_to_type_name(name)
+        else
+          raise TypeError
+        end
+      rbs_environment(collection: true).class_decls[type_name]&.then do |entry|
+        entry.decls.first.decl.type_params
+      end
+    end
+
+    def self.new_store
+      Hash.new { |h, k| h[k] = Content.new(name: k) }
+    end
+  end
+end

data/lib/orthoses/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Orthoses
+  VERSION = "0.1.0"
+end

data/lib/orthoses/walk.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Orthoses
+  class Walk
+    def initialize(loader, root:)
+      @loader = loader
+      @root = root
+    end
+
+    def call
+      @loader.call.tap do |store|
+        root = Object.const_get(@root) if @root.instance_of?(String)
+        Utils.module_name(root)&.then { |root_name| store[root_name] }
+        Orthoses::Utils.each_const_recursive(root) do |current, const, val|
+          if val.kind_of?(Module)
+            Utils.module_name(val)&.then do |val_name|
+              Orthoses.logger.debug("Add [#{val_name}] on #{__FILE__}:#{__LINE__}")
+              store[val_name]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/orthoses.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'rbs'
+require 'pathname'
+
+require_relative 'orthoses/builder'
+require_relative 'orthoses/call_tracer'
+require_relative 'orthoses/constant'
+require_relative 'orthoses/content'
+require_relative 'orthoses/create_file_by_name'
+require_relative 'orthoses/delegate_class'
+require_relative 'orthoses/filter'
+require_relative 'orthoses/include_extend_prepend'
+require_relative 'orthoses/load_rbs'
+require_relative 'orthoses/object_space_all'
+require_relative 'orthoses/pp'
+require_relative 'orthoses/store'
+require_relative 'orthoses/tap'
+require_relative 'orthoses/utils'
+require_relative 'orthoses/version'
+require_relative 'orthoses/walk'
+
+module Orthoses
+  class ConstLoadError < StandardError
+    attr_reader :root
+    attr_reader :const
+    attr_reader :error
+    def initialize(root:, const:, error:)
+      @root = root
+      @const = const
+      @error = error
+    end
+
+    def message
+      "root=#{root}, const=#{const}, error=#{error.inspect}"
+    end
+  end
+
+  class NameSpaceError < StandardError
+  end
+
+  class << self
+    attr_accessor :logger
+  end
+  self.logger = ::Logger.new($stdout, level: :info)
+end

data/orthoses.gemspec

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "lib/orthoses/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "orthoses"
+  spec.version = Orthoses::VERSION
+  spec.authors = ["ksss"]
+  spec.email = ["co000ri@gmail.com"]
+
+  spec.summary = "Framework for Generate RBS"
+  spec.description = "Build RBS by Rack base architecture"
+  spec.homepage = "https://github.com/ksss/orthoses"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 2.6.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      next true if (f == __FILE__)
+      next true if f.match?(%r{\A(?:bin|known_sig)/}) # dir
+      next true if f.match?(%r{\A\.(?:git)}) # git
+      next true if f.match?(%r{\A(?:rbs_collection|Steepfile|Rakefile)}) # top file
+      next true if f.match?(%r{_test\.rb\z}) # test
+      false
+    end
+  end
+
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "rbs", "~> 2.0"
+end

data/sig/orthoses/_call.rbs

@@ -0,0 +1,5 @@
+# THIS IS GENERATED CODE from `$ rake generate_self_sig`
+
+interface Orthoses::_Call
+  def call: () -> Hash[String, Orthoses::Content]
+end

data/sig/orthoses/_middle_ware.rbs

@@ -0,0 +1,5 @@
+# THIS IS GENERATED CODE from `$ rake generate_self_sig`
+
+interface Orthoses::_MiddleWare
+  include Orthoses::_Call
+end

data/sig/orthoses/builder/call_logable.rbs

@@ -0,0 +1,4 @@
+# THIS IS GENERATED CODE from `$ rake generate_self_sig`
+
+module Orthoses::Builder::CallLogable
+end

data/sig/orthoses/builder.rbs

@@ -0,0 +1,5 @@
+# THIS IS GENERATED CODE from `$ rake generate_self_sig`
+
+class Orthoses::Builder
+  def call: () { () -> void } -> Orthoses::store
+end

data/sig/orthoses/call_tracer.rbs

@@ -0,0 +1,5 @@
+# THIS IS GENERATED CODE from `$ rake generate_self_sig`
+
+class Orthoses::CallTracer
+  attr_accessor result: Array[[ Method, Hash[Symbol, untyped] ]]
+end

data/sig/orthoses/const_load_error.rbs

@@ -0,0 +1,8 @@
+# THIS IS GENERATED CODE from `$ rake generate_self_sig`
+
+class Orthoses::ConstLoadError < StandardError
+  attr_reader root: Module
+  attr_reader const: Symbol
+  attr_reader error: untyped
+  def initialize: (root: Module, const: Symbol, error: untyped) -> void
+end

data/sig/orthoses/constant.rbs

@@ -0,0 +1,7 @@
+# THIS IS GENERATED CODE from `$ rake generate_self_sig`
+
+class Orthoses::Constant
+  @loader: Orthoses::_Call
+  include Orthoses::_MiddleWare
+  def initialize: (Orthoses::_Call loader, ?if: ^(Module, Symbol, untyped) -> boolish, ?on_error: ^(Orthoses::ConstLoadError) -> void) -> void
+end

data/sig/orthoses/content.rbs

@@ -0,0 +1,11 @@
+# THIS IS GENERATED CODE from `$ rake generate_self_sig`
+
+class Orthoses::Content
+  attr_reader name: String
+  attr_reader body: Array[String]
+  attr_accessor header: String?
+  def initialize: (name: String) -> void
+  def <<: (String) -> void
+  def concat: (Array[String]) -> void
+  def to_rbs: () -> String
+end

data/sig/orthoses/create_file_by_name.rbs

@@ -0,0 +1,7 @@
+# THIS IS GENERATED CODE from `$ rake generate_self_sig`
+
+class Orthoses::CreateFileByName
+  @loader: Orthoses::_Call
+  include Orthoses::_MiddleWare
+  def initialize: (Orthoses::_Call loader, base_dir: String, ?header: String?) -> void
+end

data/sig/orthoses/delegate_class.rbs

@@ -0,0 +1,4 @@
+# THIS IS GENERATED CODE from `$ rake generate_self_sig`
+
+class Orthoses::DelegateClass
+end

data/sig/orthoses/filter.rbs

@@ -0,0 +1,7 @@
+# THIS IS GENERATED CODE from `$ rake generate_self_sig`
+
+class Orthoses::Filter
+  @loader: Orthoses::_Call
+  include Orthoses::_MiddleWare
+  def initialize: (Orthoses::_Call loader, if: ^(String, Orthoses::Content) -> boolish) -> void
+end

data/sig/orthoses/include_extend_prepend.rbs

@@ -0,0 +1,4 @@
+# THIS IS GENERATED CODE from `$ rake generate_self_sig`
+
+class Orthoses::IncludeExtendPrepend
+end

data/sig/orthoses/load_rbs.rbs

@@ -0,0 +1,4 @@
+# THIS IS GENERATED CODE from `$ rake generate_self_sig`
+
+class Orthoses::LoadRBS
+end

data/sig/orthoses/name_space_error.rbs

@@ -0,0 +1,4 @@
+# THIS IS GENERATED CODE from `$ rake generate_self_sig`
+
+class Orthoses::NameSpaceError < StandardError
+end

data/sig/orthoses/object_space_all.rbs

@@ -0,0 +1,4 @@
+# THIS IS GENERATED CODE from `$ rake generate_self_sig`
+
+class Orthoses::ObjectSpaceAll
+end

data/sig/orthoses/pp.rbs

@@ -0,0 +1,4 @@
+# THIS IS GENERATED CODE from `$ rake generate_self_sig`
+
+class Orthoses::PP
+end

data/sig/orthoses/store.rbs

@@ -0,0 +1,4 @@
+# THIS IS GENERATED CODE from `$ rake generate_self_sig`
+
+class Orthoses::Store
+end

data/sig/orthoses/tap.rbs

@@ -0,0 +1,4 @@
+# THIS IS GENERATED CODE from `$ rake generate_self_sig`
+
+class Orthoses::Tap
+end

data/sig/orthoses/utils.rbs

@@ -0,0 +1,27 @@
+# THIS IS GENERATED CODE from `$ rake generate_self_sig`
+
+module Orthoses::Utils
+  UNBOUND_NAME_METHOD: UnboundMethod
+
+  def self.unautoload!: () -> void
+
+  def self.each_const_recursive: (Module root, ?cache: Hash[untyped, true], ?on_error: ^(Orthoses::ConstLoadError) -> void?) ?{ (Module, Symbol, untyped) -> void } -> void
+
+  def self.rbs_defined_const?: (String name, ?library: (String | Array[String])?, ?collection: boolish) -> bool
+
+  def self.rbs_defined_class?: (String name, ?library: (String | Array[String])?, ?collection: boolish) -> bool
+
+  def self.rbs_type_name: (String) -> RBS::TypeName
+
+  def self.rbs_environment: (?library: String | Array[String] | nil, ?collection: boolish) -> RBS::Environment
+
+  def self.object_to_rbs: (untyped object, strict: bool) -> String
+
+  def self.module_name: (Module mod) -> String?
+
+  def self.module_to_type_name: (Module) -> RBS::TypeName?
+
+  def self.known_type_params: (Module | String) -> Array[RBS::AST::TypeParam]
+
+  def self.new_store: () -> Orthoses::store
+end

data/sig/orthoses/walk.rbs

@@ -0,0 +1,8 @@
+# THIS IS GENERATED CODE from `$ rake generate_self_sig`
+
+class Orthoses::Walk
+  @loader: Orthoses::_Call
+  @root: Module | String
+  include Orthoses::_MiddleWare
+  def initialize: (Orthoses::_Call loader, root: Module | String) -> void
+end

data/sig/orthoses.rbs

@@ -0,0 +1,9 @@
+# THIS IS GENERATED CODE from `$ rake generate_self_sig`
+
+module Orthoses
+  VERSION: String
+
+  attr_accessor self.logger: ::Logger
+
+  type store = Hash[String, Orthoses::Content]
+end