steep-activesupport-4 1.9.3

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Soutaro Matsumoto
+
+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,260 @@
+> [!IMPORTANT]
+> This is a fork of the [Steep gem](https://github.com/soutaro/steep). This fork exists primarily to support a legacy system that relies on ActiveSupport 4.2.
+
+---
+
+# Steep - Gradual Typing for Ruby
+
+## Installation
+
+Install via RubyGems.
+
+    $ gem install steep
+
+### Requirements
+
+Steep requires Ruby 2.6 or later.
+
+## Usage
+
+Steep does not infer types from Ruby programs, but requires declaring types and writing annotations.
+You have to go on the following three steps.
+
+### 0. `steep init`
+
+Run `steep init` to generate a configuration file.
+
+```
+$ steep init       # Generates Steepfile
+```
+
+Edit the `Steepfile`:
+
+```rb
+target :app do
+  check "lib"
+  signature "sig"
+
+  library "pathname"
+end
+```
+
+### 1. Declare Types
+
+Declare types in `.rbs` files in `sig` directory.
+
+```
+class Person
+  @name: String
+  @contacts: Array[Email | Phone]
+
+  def initialize: (name: String) -> untyped
+  def name: -> String
+  def contacts: -> Array[Email | Phone]
+  def guess_country: -> (String | nil)
+end
+
+class Email
+  @address: String
+
+  def initialize: (address: String) -> untyped
+  def address: -> String
+end
+
+class Phone
+  @country: String
+  @number: String
+
+  def initialize: (country: String, number: String) -> untyped
+  def country: -> String
+  def number: -> String
+
+  def self.countries: -> Hash[String, String]
+end
+```
+
+- You can use simple _generics_, like `Hash[String, String]`.
+- You can use _union types_, like `Email | Phone`.
+- You have to declare not only public methods but also private methods and instance variables.
+- You can declare _singleton methods_, like `self.countries`.
+- There is `nil` type to represent _nullable_ types.
+
+### 2. Write Ruby Code
+
+Write Ruby code with annotations.
+
+```rb
+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 `untyped`, 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, 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 `untyped`, 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, country, number].hash
+  end
+end
+```
+
+### 3. Type Check
+
+Run `steep check` command to type check. 💡
+
+```
+$ steep check
+lib/phone.rb:46:0: MethodDefinitionMissing: module=::Phone, method=self.countries (class Phone)
+```
+
+You now find `Phone.countries` method is not implemented yet. 🙃
+
+## Prototyping signature
+
+You can use `rbs prototype` command to generate a signature declaration.
+
+```
+$ rbs prototype rb lib/person.rb lib/email.rb lib/phone.rb
+class Person
+  @name: untyped
+  @contacts: Array[untyped]
+  def initialize: (name: untyped) -> Array[untyped]
+  def guess_country: () -> untyped
+end
+
+class Email
+  @address: untyped
+  def initialize: (address: untyped) -> untyped
+  def ==: (untyped) -> untyped
+  def hash: () -> untyped
+end
+
+class Phone
+  @country: untyped
+  @number: untyped
+  def initialize: (country: untyped, number: untyped) -> untyped
+  def ==: (untyped) -> void
+  def hash: () -> untyped
+end
+```
+
+It prints all methods, classes, instance variables, and constants.
+It can be a good starting point to writing signatures.
+
+Because it just prints all `def`s, you may find some odd points:
+
+- The type of `initialize` in `Person` looks strange.
+- There are no `attr_reader` methods extracted.
+
+Generally, these are by our design.
+
+`rbs prototype` offers options: `rbi` to generate prototype from Sorbet RBI and `runtime` to generate from runtime API.
+
+## Docs
+
+There are some documents in the `manul` and `guide` directories.
+
+- [Guides](guides)
+- [Manual](manual)
+
+The `doc` directory contains a few internal design docs.
+
+- [Internal docs](doc)
+
+## Examples
+
+You can find examples in `smoke` directory.
+
+## IDEs
+
+Steep implements some of the Language Server Protocol features.
+
+- For **VSCode** please install [the plugin](https://github.com/soutaro/steep-vscode).
+- For **SublimeText** please install [LSP](https://github.com/sublimelsp/LSP) package and follow [instructions](https://lsp.sublimetext.io/language_servers/#steep).
+- For **Vim** or **Neovim** please install [ALE](https://github.com/dense-analysis/ale?tab=readme-ov-file#asynchronous-lint-engine). You may want to `let g:ale_ruby_steep_executable = 'bundle'` to use your bundled `steep` version.
+
+Other LSP supporting tools may work with Steep where it starts the server as `steep langserver`.
+
+## Rake Tasks
+
+Steep comes with a set of configurable Rake tasks.
+
+```ruby
+# Rakefile
+
+require "steep/rake_task"
+Steep::RakeTask.new do |t|
+  t.check.severity_level = :error
+  t.watch.verbose
+end
+
+task default: [:steep]
+```
+
+Use `bundle exec rake -T` to see all available tasks.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` 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/soutaro/steep.

data/Rakefile

@@ -0,0 +1,227 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+if ENV["VSCODE_CWD"]
+  require "minitest"
+  Minitest.seed = Time.now.to_i
+end
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task :default => :test
+
+namespace :test do
+  desc "Run output test"
+  task :output do
+    sh "ruby", "bin/output_test.rb"
+  end
+end
+
+# Disable the following task enhancement add upstream
+# Rake::Task[:release].enhance do
+#   Rake::Task[:"release:note"].invoke
+#   Rake::Task[:"release:github"].invoke
+#   Rake::Task[:"release:release-prs"].invoke
+# end
+
+desc "Generate changelog template from GH pull requests"
+task :changelog do
+  major, minor, patch, pre = Steep::VERSION.split(".", 4)
+  major = major.to_i
+  minor = minor.to_i
+  patch = patch.to_i
+
+  if patch == 0
+    milestone = "Steep #{major}.#{minor}"
+  else
+    milestone = "Steep #{major}.#{minor}.x"
+  end
+
+  puts "🔍 Finding pull requests that is associated to milestone `#{milestone}`..."
+
+  command = [
+    "gh",
+    "pr",
+    "list",
+    "--json",
+    "url,title,number",
+    "--limit=100",
+    "--search" ,
+    "milestone:\"#{milestone}\" is:merged sort:updated-desc -label:Released"
+  ]
+
+  require "open3"
+  output, status = Open3.capture2(*command)
+  raise status.inspect unless status.success?
+
+  require "json"
+  json = JSON.parse(output, symbolize_names: true)
+
+  unless json.empty?
+    puts
+    json.each do |line|
+      puts "* #{line[:title]} ([##{line[:number]}](#{line[:url]}))"
+    end
+  else
+    puts "  (🤑 There is no *unreleased* pull request associated to the milestone.)"
+  end
+end
+
+namespace :release do
+  desc "Ensure release note"
+  task :note do
+    version = Gem::Version.new(Steep::VERSION)
+    major, minor, patch, pre = Steep::VERSION.split(".", 4)
+    major = major.to_i
+    minor = minor.to_i
+    patch = patch.to_i
+
+    wiki_url = "https://github.com/soutaro/steep/wiki/Release-Note-#{major}.#{minor}"
+
+    puts "🧐 Checking if Release note page already exists..."
+
+    unless `curl --silent -o/dev/null --head #{wiki_url} -w '%{http_code}'` == "200"
+      pre_flag = version.prerelease? ? " --pre" : ""
+      pre_requirement = version.prerelease? ? ", '~> #{major}.#{minor}.#{patch}.#{pre}'" : ""
+
+      puts "----"
+
+      puts <<~PREFIX if patch
+        **The latest version of Steep #{major}.#{minor} is `#{pre}`.**
+
+      PREFIX
+
+      puts <<~TEMPLATE
+        Some of the highlights in Steep #{major}.#{minor} are:
+
+        * New feature 1 (URL)
+        * New feature 2 (URL)
+        * New feature 3 (URL)
+
+        You can install it with `$ gem install steep#{pre_flag}` or using Bundler.
+
+        ```rb
+        gem 'steep', require: false#{pre_requirement}
+        ```
+
+        See the [CHANGELOG](https://github.com/soutaro/steep/blob/master/CHANGELOG.md) for the details.
+
+        ## New feature 1
+
+        ## New feature 2
+
+        ## New feature 3
+
+        ## Diagnostics updates
+
+        ## Updating Steep
+
+      TEMPLATE
+      puts "----"
+      puts
+
+      puts "  ⏩️ Create the release note with the template: #{wiki_url}"
+    else
+      if patch == 0 || version.prerelease?
+        puts "  ⏩️ Open the release note and update it at: #{wiki_url}"
+      else
+        puts "  ✅ Release note is ready!"
+      end
+    end
+    puts
+  end
+
+  desc "Create GitHub release automatically"
+  task :github do
+    version = Gem::Version.new(Steep::VERSION)
+    major, minor, patch, *_ = Steep::VERSION.split(".")
+    major = major.to_i
+    minor = minor.to_i
+    patch = patch.to_i
+
+    puts "✏️ Making a draft release on GitHub..."
+
+    content = File.read(File.join(__dir__, "CHANGELOG.md"))
+    changelog = content.scan(/^## \d.*?(?=^## \d)/m)[0]
+    changelog = changelog.sub(/^.*\n^.*\n/, "").rstrip
+
+    notes = <<NOTES
+[Release note](https://github.com/soutaro/steep/wiki/Release-Note-#{major}.#{minor})
+
+#{changelog}
+NOTES
+
+    command = [
+      "gh",
+      "release",
+      "create",
+      "--draft",
+      "v#{Steep::VERSION}",
+      "--title=#{Steep::VERSION}",
+      "--notes=#{notes}"
+    ]
+
+    if version.prerelease?
+      command << "--prerelease"
+    end
+
+    require "open3"
+    output, status = Open3.capture2(*command)
+    if status.success?
+      puts "  ⏩️ Done! Open #{output.chomp} and publish the release!"
+      puts
+    end
+  end
+
+  desc "Add `Released` labels to pull requests associated to the version"
+  task "release-prs" do
+    major, minor, patch, pre = Steep::VERSION.split(".", 4)
+    major = major.to_i
+    minor = minor.to_i
+    patch = patch.to_i
+
+    if patch == 0
+      milestone = "Steep #{major}.#{minor}"
+    else
+      milestone = "Steep #{major}.#{minor}.x"
+    end
+
+    if pre =~ /dev/
+      puts "🔍 Skipping `Released` tags because `dev` release: `#{pre}`"
+      next
+    end
+
+    puts "🔍 Finding pull requests that is associated to milestone `#{milestone}`..."
+
+    command = [
+      "gh",
+      "pr",
+      "list",
+      "--json",
+      "url,title,number",
+      "--search" ,
+      "milestone:\"#{milestone}\" is:merged sort:updated-desc -label:Released"
+    ]
+
+    require "open3"
+    output, status = Open3.capture2(*command)
+    raise status.inspect unless status.success?
+
+    require "json"
+    json = JSON.parse(output, symbolize_names: true)
+
+    puts "  ✅ Found #{json.size} PRs..."
+
+    json.each do |pr|
+      puts "🧐 Updating #{pr[:url]}..."
+      output, status = Open3.capture2("gh", "pr", "edit", pr[:number].to_s, "--add-label", "Released")
+      raise status.inspect unless status.success?
+      puts "  ✅ Done!"
+      sleep 0.5
+    end
+  end
+end

data/Steepfile

@@ -0,0 +1,68 @@
+require "fileutils"
+
+D = Steep::Diagnostic
+
+FileUtils.mkpath("tmp")
+tmp_rbs_dir = Pathname("tmp/rbs-sig")
+
+definition = Bundler::Definition.build(Pathname("Gemfile"), Pathname("Gemfile.lock"), nil)
+rbs_dep = definition.dependencies.find {|dep| dep.name == "rbs" }
+if (source = rbs_dep&.source).is_a?(Bundler::Source::Path)
+  unless tmp_rbs_dir.directory?
+    FileUtils.ln_s(Pathname.pwd + source.path + "sig", tmp_rbs_dir.to_s, force: true)
+  end
+else
+  FileUtils.rm_f(tmp_rbs_dir)
+  library "rbs"
+end
+
+target :app do
+  collection_config "rbs_collection.steep.yaml"
+
+  check "lib"
+  ignore "lib/steep/shims"
+
+  signature "sig"
+  ignore_signature "sig/test"
+
+  implicitly_returns_nil!
+
+  configure_code_diagnostics(D::Ruby.strict) do |hash|
+  end
+
+  if tmp_rbs_dir.directory?
+    signature tmp_rbs_dir.to_s
+  else
+    library "rbs"
+  end
+end
+
+target :test do
+  collection_config "rbs_collection.steep.yaml"
+
+  unreferenced!
+  implicitly_returns_nil!
+
+  check "test"
+  signature "sig/test"
+
+  configure_code_diagnostics(D::Ruby.lenient)
+
+  if tmp_rbs_dir.directory?
+    signature tmp_rbs_dir.to_s
+  else
+    library "rbs"
+  end
+end
+
+target :bin do
+  unreferenced!
+  implicitly_returns_nil!
+
+  collection_config "rbs_collection.steep.yaml"
+
+  check "bin/generate-diagnostics-docs.rb"
+  signature "tmp/rbs-inline/bin"
+
+  library "rbs"
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "steep"
+
+# 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

data/bin/generate-diagnostics-docs.rb

@@ -0,0 +1,112 @@
+# rbs_inline: enabled
+
+require "rbs"
+require "steep"
+
+class RubyDiagnosticsVisitor < RBS::AST::Visitor
+  attr_reader :classes #: Hash[String, String]
+  attr_reader :templates #: Hash[Symbol, String]
+
+  def initialize #: void
+    @classes = {}
+    @templates = {}
+  end
+
+  # @rbs ...
+  def visit_declaration_class(node)
+    unless node.annotations.find { _1.string == "diagnostics--skip" }
+      if node.comment
+        name = node.name.to_s
+        classes[name] = node.comment.string
+      end
+    end
+
+    super
+  end
+
+  # @rbs ...
+  def visit_member_method_definition(node)
+    if node.annotations.find { _1.string == "diagnostics--template" }
+      if node.comment
+        templates[node.name] = node.comment.string
+      end
+    end
+  end
+
+  # @rbs (IO) -> void
+  def format_templates(io)
+    io.puts "## Configuration Templates"
+
+    io.puts <<~MD
+      Steep provides several templates to configure diagnostics for Ruby code.
+      You can use these templates or customize them to suit your needs via `#configure_code_diagnostics` method in `Steepfile`.
+
+      The following templates are available:
+
+    MD
+
+    io.puts "<dl>"
+    templates.keys.sort.each do |key|
+      body = templates.fetch(key)
+
+      io.puts "<dt><code>Ruby.#{key}</code></dt>"
+      io.puts "<dd>#{body}</dd>"
+    end
+    io.puts "</dl>"
+    io.puts
+  end
+
+  # @rbs (IO) -> void
+  def format_class(io)
+    classes.keys.sort.each do |key|
+      content = classes[key]
+
+      # io.puts "<h2 id='Ruby::#{key}'>Ruby::#{key}</h2>"
+      io.puts "<a name='Ruby::#{key}'></a>"
+      io.puts "## Ruby::#{key}"
+      io.puts
+      io.puts content
+      io.puts
+
+      configs = templates.keys
+
+      io.puts "### Severity"
+      io.puts
+      io.puts "| #{configs.map { "#{_1}" }.join(" | ")} |"
+      io.puts "| #{configs.map{"-"}.join(" | ")} |"
+
+      line = configs.map {|config|
+        hash = Steep::Diagnostic::Ruby.__send__(config) #: Hash[Class, untyped]
+        const =Steep::Diagnostic::Ruby.const_get(key.to_sym)
+        "#{hash[const] || "-"}"
+      }
+      io.puts "| #{line.join(" | ")} |"
+      io.puts
+    end
+  end
+
+  # @rbs (Pathname) { (instance) -> void } -> void
+  def self.visit_file(path, &block)
+    STDERR.puts "Reading #{path}..."
+    buffer = RBS::Buffer.new(name: path, content: path.read)
+    _, _dirs, decls = RBS::Parser.parse_signature(buffer)
+
+    visitor = new()
+    visitor.visit_all(decls)
+
+    yield visitor
+  end
+end
+
+diagnostic_dir = Pathname(__dir__ || raise) + "../sig/steep/diagnostic"
+output_dir = Pathname(__dir__ || raise) + "../manual"
+
+RubyDiagnosticsVisitor.visit_file(diagnostic_dir + "ruby.rbs") do |visitor|
+  STDERR.puts ">> Writing #{output_dir + "ruby-diagnostics.md"}..."
+  (output_dir + "ruby-diagnostics.md").open("w") do |io|
+    io.puts "# Ruby Code Diagnostics"
+    io.puts
+    visitor.format_templates(io)
+    visitor.format_class(io)
+  end
+end