solargraph-rails 1.1.2 → 1.2.0

data/.solargraph.yml

@@ -2,10 +2,13 @@
 include:
 - "**/*.rb"
 exclude:
-- test/**/*
+- spec/**/*
+- lib/solargraph/rails/annotations/**/*
 - vendor/**/*
 - ".bundle/**/*"
-require: []
+require:
+  # we generally assume a solargraph require has been made and don't make it explicitly
+  - solargraph
 domains: []
 reporters: []
 formatter:

data/CHANGELOG.md

@@ -2,6 +2,42 @@
 
 ## Changes
 
+### v1.2
+
+Most of these are courtesy of @grndr, with integration work by
+@iftheshoefritz and @apiology
+
+Features / fixes:
+- Unlock support for Solargraph ~>0.56.0, with [major
+  improvements](https://github.com/castwide/solargraph/blob/master/CHANGELOG.md)
+  across the board
+- Support writers in Rails models
+- Support `gem_rbs_collection` for better quality Rails types
+- Use Solargraph::Pin::DelegatedMethod to define delegate methods
+- Include overloads and parameter types for ActiveRecord methods
+- Improve private relation support for ActiveRecord
+- Add find_by_column methods, clean up spec (Thanks, @ShadiestGoat!)
+- Annotation improvements driven by testing
+
+
+Internal improvements:
+- Many CI, linting and testing improvements
+  - Extract Util.extract_option helper
+  - Remove Rails 5 & Rails 6 specs
+  - Configure test app to behave like a real app
+  - Use ruby/setup-ruby action and test app Gemfile for CI
+  - Add a plugin that generates yard docs after bundle install
+  - Update test pin definitions and exclusions to be Solargraph and
+    Rails version-focused in a single location
+  - Working build matrix with heavy caching
+  - Add typecheck workflow
+- Use Solargraph::Pin::DelegatedMethod to define delegate methods
+- Update README introduction
+- Update model spec to expect private relation types
+- Fix undefined closure for generated parameter pins
+- Add Rails 7.1, 7.2 and 8.0 to test matrix
+- README.md example bug fix (Thanks, @snuggs!)
+
 ### v1.1.2
 
 Features / fixes:
@@ -14,7 +50,6 @@ Internal improvements:
 - Use normal ruby source for extra YARD annotations (Thanks, @grncdr!)
 - Speed up CI for recent Solargraph version fresh builds
 - spec reliability fixes
--
 
 ### v1.1.1
 

data/DEVELOPMENT.md

@@ -1,19 +1,5 @@
 # Solargraph-Rails development guide
 
-## Contributing
-
-1. create fork and clone the repo
-2. install gem deps `bundle install`
-3. install dummy Rails app deps and build its yard cache
-
-    ```
-    $ cd spec/rails7
-    $ bundle install && yard gems
-    $ cd ../../
-    ```
-4. now tests should pass locally and you can try different changes
-5. submit PR
-
 ## Debugging workflow / test matrix issues locally
 
 ```sh
@@ -24,7 +10,7 @@ act pull_request
 ## Completion coverage tracking
 
 Solargraph-Rails uses a [set of yaml files](https://github.com/iftheshoefritz/solargraph-rails/tree/master/spec/definitions) to track coverage of found completions.
-Those yaml files are generated at runtime from a dummy [Rails 7 app](https://github.com/iftheshoefritz/solargraph-rails/tree/master/spec/rails7).
+Those yaml files are generated at runtime from a dummy Rails apps in the spec/rails* directories.
 
 The main goal is to catch any regressions in case of any change. In case a method completion is marked completed and it is not found in solargraph completions, the tests will fail.
 
@@ -48,7 +34,7 @@ What you will see in test output is reported coverage for classes that are track
 In case an improvement is made, and more completions are found then being asserted, tests will throw a warning:
 
 ```
-ActionDispatch::Routing::Mapper.try! is marked as skipped in spec/definitions/rails5/routes.yml, but is actually present.
+ActionDispatch::Routing::Mapper.try! is marked as skipped in spec/definitions/routes.yml, but is actually present.
 Consider setting skip=false
   provides completions for ActionDispatch::Routing::Mapper
 ```
@@ -76,15 +62,18 @@ In case a new set of assertion files has to be created (for a new Rails version
 All you have to do is execute the script and pass it a path to rails app:
 
 ```
-ruby script/generate_definitions.rb spec/rails7
+cd spec/rails8
+rails g model model
+rails db:drop db:create db:migrate
+bundle exec ruby ../../script/generate_definitions.rb .
 ```
 
-Make sure to review the script and uncomment relevant parts
+Move .yml files into place, then make sure to review the script and uncomment relevant parts
 
 ## Preparing a release (maintainers)
 
 1. Look up [most recent release](https://rubygems.org/gems/solargraph-rails)
-2. Open up commit list(https://github.com/iftheshoefritz/solargraph-rails/compare/v1.1.1...main)
+2. Open up [commit list](https://github.com/iftheshoefritz/solargraph-rails/compare/v1.1.2...main)
 3. Update [CHANGELOG.md](./CHANGELOG.md)
 4. Flip to 'files changed view' and refine updates
 5. Bump [version](./lib/solargraph/rails/version.rb) appropriately

data/Gemfile

@@ -1,14 +1,14 @@
 source 'https://rubygems.org'
 
-
 # Kind of ugly, but works. The setup-ruby action forces gems to be installed to vendor/bundle
-# If we use it naively we end up with vendor/bundle  and spec/rails7/vendor/bundle, which
+# If we use it naively we end up with vendor/bundle  and spec/rails*/vendor/bundle, which
 # breaks all the tests because docs are generated in two different directories.
 #
 # So if we just install the rails deps at the same time, we have a single cache and a single
 # directory for gems.
-rails_version = ENV['MATRIX_RAILS_VERSION'] || '7'
-instance_eval File.read(File.expand_path("spec/rails#{rails_version}/Gemfile", __dir__))
+rails_version = (ENV['CI'] && ENV['MATRIX_RAILS_VERSION']) || '7.2'
+rails_major_version = rails_version.split('.').first
+instance_eval File.read(File.expand_path("spec/rails#{rails_major_version}/Gemfile", __dir__))
 
 solargraph_version = (ENV['CI'] && ENV['MATRIX_SOLARGRAPH_VERSION'])
 
@@ -30,7 +30,18 @@ group :development, :test do
   gem 'byebug'
 end
 
-if rails_version == '7'
+group :development, :rubocop do
+  gem 'rubocop', require: false
+  gem 'rubocop-rake', require: false
+  gem 'rubocop-rspec', require: false
+  gem 'rubocop-performance', require: false
+  gem 'overcommit'
+  gem 'simplecov-lcov',
+      github: 'apiology/simplecov-lcov',
+      branch: 'avoid_blank_lines'
+end
+
+if rails_major_version == '7'
   # https://stackoverflow.com/questions/79360526/uninitialized-constant-activesupportloggerthreadsafelevellogger-nameerror
   gem "concurrent-ruby", '<=1.3.5'
 end
@@ -40,11 +51,12 @@ gemspec
 
 solargraph_force_ci_version = (ENV['CI'] && ENV['MATRIX_SOLARGRAPH_VERSION'])
 
-if solargraph_force_ci_version == '0.54.6.alpha'
+case solargraph_force_ci_version
+when '0.56.alpha'
   gem 'solargraph',
       github: 'apiology/solargraph',
-      branch: 'v54-alpha'
-    # path: '../solargraph'
+      branch: '2025-06-24'
+      # path: '../solargraph'
 end
 
 # Local gemfile for development tools, etc.

data/README.md

@@ -1,46 +1,48 @@
 # Solargraph::Rails - Help solargraph with Rails
 
 ## Models
-Given a typical Rails model like this:
+Consider pair of typical Rails models like this:
+
+```sh
+rails g model Author lastname:string firstnames:string
+rails g model Book title:string isbn:string author:belongs_to
+```
 
 ```ruby
-# == Schema Information
-#
-# Table name: my_books
-#
-#  id         :integer          not null, primary key
-#  author     :string
-#  name       :string
-#  created_at :datetime         not null
-#  updated_at :datetime         not null
-#
-class MyBook < ApplicationRecord
-  def my_method
-    "hello"
+class Author < ApplicationRecord
+  has_many :books
+
+  def sortable_name
+    "#{lastname}, #{firstnames}"
   end
+end
 
-  ...
+class Book < ApplicationRecord
+  belongs_to :author
 
+  def label
+    [author.sortable_name, title, isbn].join("\n")
+  end
 end
 ```
 
-The various Ruby intellisense tools are ok at knowing that there is a `MyBook` constant, and some (including Solargraph) are aware that objects like `MyBook.new` have a method `.my_method`. But what about those magical dynamic attributes that ActiveRecord creates when Rails starts up? You can see these listed at the top of the file under `# == Schema Information`, the comments helpfully added by the Annotate gem.
+The various Ruby intellisense tools are ok at knowing that there are `Book` and `Author` constants, and some (including Solargraph) are aware that objects like `Book.new` have a `.label` method. But what about those "magical" dynamic methods that ActiveRecord creates like `.title`, or `.author`?
 
-Since these attributes are only created at runtime, static analysis alone can't identify them. Your editor has no idea that these attributes exist, but they're amongst the most common things that you will work with in any Rails app.
+Since these attributes are only created at runtime, a simple static analysis of the `Book` class alone can't identify them. Your editor has no idea that these attributes exist, but they're amongst the most common things that you will work with in any Rails app.
 
-That's where this plugin for Solargraph comes in: it parses the database schema and YARD docs of various gems to give Solargraph some extra hints. For instance database attributes:
+That's where this plugin for Solargraph comes in: it understands db/schema.rb and any comments from the annotate\_models gem for models, and also supplies key annotations and Rails-specific context on top of what Solargraph pulls via YARD and RBS.   As a result, you have access to database attributes:
 
  ![Go to attribute schema definition](assets/sg_rails_1_0_go_to_attribute_definition.gif)
 
- ... or ActiveRecord finders:
+ ... and ActiveRecord finders:
 
  ![ActiveRecord method support](assets/sg_rails_1_0_activerecord_support.gif)
 
- ... or associations:
+ ... and associations:
 
  ![Association support](assets/sg_rails_1_0_association_completion.gif)
 
- ... or routes file:
+ ... and routes file syntax:
 
  ![Routes file support](assets/sg_rails_1_0_routes_support.gif)
 
@@ -52,6 +54,16 @@ and more!
 
 If you add them to your Gemfile, you'll have to tell your IDE plugin to use bundler to load the right version of solargraph.
 
+### Import Rails RBS types
+
+Use [gem\_rbs\_collection](https://github.com/ruby/gem_rbs_collection)
+to install RBS types for Rails:
+
+```sh
+rbs collection init
+rbs collection install
+```
+
 ### Add `solargraph-rails` to your `.solargraph.yml`
 
 (if you don't have a `.solargraph.yml` in your project root, you can run `solargraph config` to add one)
@@ -71,18 +83,19 @@ Bug reports and pull requests are welcome on GitHub at https://github.com/ifthes
 
 2. install gem deps `bundle install`
 
-3. install dummy rails app deps and build the yard cache:
+3. install dummy rails app deps:
 
 ```
-$ cd spec/rails7
-$ bundle install && yard gems
-$ cd ../../
+cd spec/rails7 && bundle install && rbs collection init && rbs collection install && cd ../../
+cd spec/rails8 && bundle install && rbs collection init && rbs collection install && cd ../../
 ```
 
 4. now tests should pass locally and you can try different changes
 
 5. submit PR
 
+See [DEVELOPMENT.md](./DEVELOPMENT.md) for more information
+
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/bin/overcommit

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'overcommit' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../Gemfile", __dir__)
+
+bundle_binstub = File.expand_path("bundle", __dir__)
+
+if File.file?(bundle_binstub)
+  if File.read(bundle_binstub, 300).include?("This file was generated by Bundler")
+    load(bundle_binstub)
+  else
+    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
+  end
+end
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("overcommit", "overcommit")

data/bin/rubocop

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'rubocop' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../Gemfile", __dir__)
+
+bundle_binstub = File.expand_path("bundle", __dir__)
+
+if File.file?(bundle_binstub)
+  if File.read(bundle_binstub, 300).include?("This file was generated by Bundler")
+    load(bundle_binstub)
+  else
+    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
+  end
+end
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("rubocop", "rubocop")

data/ci/auto_yard/plugins.rb

@@ -1,5 +1,4 @@
 Bundler::Plugin.add_hook('after-install-all') do
-  system('bundle exec yard gems')
   cmd = 'bundle exec yard gems --plugin solargraph'
   STDERR.puts("Installing yard info using #{cmd.inspect}")
   # Attempt to run yard, and if it fails, try again - sometimes YARD gets indigestion on a given gem

data/lib/solargraph/rails/annotate.rb

@@ -35,6 +35,16 @@ module Solargraph
               location:
                 Solargraph::Location.new(source_map.filename, snip.range)
             )
+
+          pins <<
+            Util.build_public_method(
+              ns,
+              "#{name}=",
+              types: [ruby_type],
+              params: { 'value' => [ruby_type] },
+              location:
+                Solargraph::Location.new(source_map.filename, snip.range)
+            )
         end
 
         pins

data/lib/solargraph/rails/annotations/action_controller.rb

@@ -1,12 +1,59 @@
 class ActionController::Base
-  include ActionController::MimeResponds
-  include ActionController::Redirecting
-  include ActionController::Cookies
+  #
+  # NOTE: keep this list synced with new items from MODULES in action_controller/base.rb
+  #
+  # @todo pull this as literal array dynamically from
+  #  ActionController::Base::MODULES and walk through it (and other
+  #  cases of same pattern) to help future-proof things
+  #
   include AbstractController::Rendering
+  extend AbstractController::Rendering::ClassMethods
+  include AbstractController::Translation
+  include AbstractController::AssetPaths
+  include Helpers
+  include UrlFor
+  include Redirecting
+  include ActionView::Layouts
+  include Rendering
+  include Renderers::All
+  include ConditionalGet
+  include EtagWithTemplateDigest
+  include EtagWithFlash
+  include Caching
+  include MimeResponds
+  include ImplicitRender
+  include StrongParameters
+  include ParameterEncoding
+  include Cookies
+  include Flash
+  include FormBuilder
+  include RequestForgeryProtection
+  extend RequestForgeryProtection::ClassMethods
+  include ContentSecurityPolicy
+  include PermissionsPolicy
+  extend PermissionsPolicy::ClassMethods
+  include Streaming
+  include DataStreaming
+  include HttpAuthentication::Basic::ControllerMethods
+  extend HttpAuthentication::Basic::ControllerMethods::ClassMethods
+  include HttpAuthentication::Digest::ControllerMethods
+  include HttpAuthentication::Token::ControllerMethods
+  include DefaultHeaders
+  include Logging
+  extend Logging::ClassMethods
+  include AbstractController::Callbacks
+  extend AbstractController::Callbacks::ClassMethods
+  include Rescue
+  include Instrumentation
+  include ParamsWrapper
+
+  #
+  # I don't see the thinsg below in action_controller/base.rb, at least in Rails
+  # 7.0.  Maybe they need to be moved to be under a different class?
+  #
   extend ActiveSupport::Callbacks::ClassMethods
   extend ActiveSupport::Rescuable::ClassMethods
-  extend AbstractController::Callbacks::ClassMethods
-  extend ActionController::RequestForgeryProtection::ClassMethods
+  include ActiveSupport::Rescuable
 
   # @return [ActionDispatch::Response]
   def response; end
@@ -27,3 +74,8 @@ class ActionController::Cookies
   # @return [ActionDispatch::Cookies::CookieJar]
   def cookies; end
 end
+
+class ActionController::StrongParameters
+  # @return [ActionController::Parameters]
+  def params; end
+end

data/lib/solargraph/rails/annotations/active_model.rb

@@ -0,0 +1,18 @@
+module ActiveModel
+  module Translation
+    # @param options [Hash] options to customize the output
+    # @param attribute [Symbol, String] the name of the attribute
+    # @return [String]
+    def human_attribute_name(attribute, options = {}); end
+  end
+
+  module Naming
+    # @return [ActiveModel::Name] the model name for the class
+    def model_name; end
+  end
+
+  module Validations
+    # @return [Boolean]
+    def validate; end
+  end
+end

data/lib/solargraph/rails/annotations/active_record.rb

@@ -1,10 +1,14 @@
 class ActiveRecord::ConnectionAdapters::SchemaStatements
   # @yieldparam [ActiveRecord::ConnectionAdapters::TableDefinition]
-  def create_table; end
+  # @return [void]
+  def create_table(table_name, id: nil, primary_key: nil, force: false, **options); end
   # @yieldparam [ActiveRecord::ConnectionAdapters::TableDefinition]
-  def create_join_table; end
+  # @param column_options [Hash]
+  # @return [void]
+  def create_join_table(table_1, table_2, column_options: {}, **options); end
   # @yieldparam [ActiveRecord::ConnectionAdapters::Table]
-  def change_table; end
+  # @return [void]
+  def change_table(table_name, **options); end
 end
 
 # this module doesn't really exist, it's here to avoid repeating these mixins
@@ -33,6 +37,21 @@ class ActiveRecord::Base
   extend ActiveRecord::Scoping::Named::ClassMethods
   extend ActiveRecord::RelationMethods
   include ActiveRecord::Persistence
+  extend ActiveModel::AttributeRegistration::ClassMethods
+  # note: this supplies set_callback() - after Rails 7.1, this is no
+  #  longer used and is replaced entirely by ActiveRecord::Callbacks
+  #  below
+  include ActiveRecord::Callbacks
+  extend ActiveRecord::Callbacks::ClassMethods
+  extend Translation
+
+  def self.set_callback
+  end
+end
+
+module ActiveRecord::Validations
+  # @return [Boolean]
+  def validate; end
 end
 
 # @!override ActiveRecord::Batches#find_each
@@ -52,3 +71,5 @@ end
 #   @return_single_parameter
 # @!override ActiveRecord::QueryMethods::WhereChain#associated
 #   @return_single_parameter
+# @!override ActiveRecord::ConnectionAdapters::SchemaStatements#create_table
+#   @yieldparam [ActiveRecord::ConnectionAdapters::TableDefinition]

data/lib/solargraph/rails/annotations/active_support.rb

@@ -3,3 +3,6 @@
 
 # @!override ActiveSupport::DescendantsTracker#subclasses
 #   @return [Array<Class>]
+
+# @!override ActiveSupport::DescendantsTracker::ReloadedClassesFiltering#subclasses
+#   @return [Array<Class>]

data/lib/solargraph/rails/annotations/array.rb

@@ -0,0 +1,3 @@
+class Array
+  def sum; end
+end

data/lib/solargraph/rails/annotations/class.rb

@@ -0,0 +1,2 @@
+# @!override Class#subclasses
+#   @return [Array<Class>]

data/lib/solargraph/rails/annotations/module.rb

@@ -0,0 +1,13 @@
+class Module
+  # @return [self, nil]
+  def self.presence; end
+
+  # @return [self, nil]
+  def self.presence_in(x); end
+
+  # @return [self, nil]
+  def presence; end
+
+  # @return [self, nil]
+  def presence_in(x); end
+end

data/lib/solargraph/rails/annotations/object.rb

@@ -5,3 +5,6 @@ class Object
   # @return [self, nil]
   def presence_in(x); end
 end
+
+# @!override Object#present?
+#   @return [Boolean]

data/lib/solargraph/rails/annotations/time.rb

@@ -24,7 +24,7 @@ class Time
 
   # @return [Time]
   def to_time; end
-
-  # @return [Time]
-  def +(other); end
 end
+
+# @!override Time#+
+#   @return [Time]

data/lib/solargraph/rails/delegate.rb

@@ -1,3 +1,5 @@
+require 'parser'
+
 module Solargraph
   module Rails
     class Delegate
@@ -5,25 +7,57 @@ module Solargraph
         @instance ||= self.new
       end
 
+      def self.supported?
+        Solargraph::Pin.const_defined?(:DelegatedMethod)
+      end
+
       def process(source_map, ns)
+        return [] unless self.class.supported?
         return [] unless source_map.code.include?('delegate')
 
         walker = Walker.from_source(source_map.source)
         pins = []
 
         walker.on :send, [nil, :delegate] do |ast|
-          methods =
-            ast.children[2..-1]
-              .map { |c| c.children.first }
-              .select { |s| s.is_a?(Symbol) }
+          last_child = ast.children[-1]
+          next unless last_child.instance_of?(::Parser::AST::Node) && last_child.type == :hash
+
+          methods = ast.children[2...-1].select { |c| c.type == :sym }
+
+          delegate_node = Util.extract_option(ast, :to)
+          next unless delegate_node
+
+          chain = if delegate_node.type == :sym
+            # `delegate ..., to: :bar` means call the #bar method to get the delegate object
+            call = Solargraph::Source::Chain::Call.new(delegate_node.children[0].to_s)
+            Solargraph::Source::Chain.new([call], delegate_node)
+          else
+            # for any other type of delegate, we create a chain from the AST node
+            Solargraph::Parser::Legacy::NodeChainer.chain(delegate_node, ns.filename)
+          end
+
+          prefix_node = Util.extract_option(ast, :prefix)
+
+          prefix = nil
+          if prefix_node
+            if prefix_node.type == :sym
+              prefix = prefix_node.children[0]
+            elsif prefix_node.type == :true && delegate_node.type == :sym
+              prefix = delegate_node.children[0]
+            end
+          end
 
+          location = Util.build_location(delegate_node, ns.filename)
           methods.each do |meth|
-            pins <<
-              Util.build_public_method(
-                ns,
-                meth.to_s,
-                location: Util.build_location(ast, ns.filename)
-              )
+            method_name = meth.children[0]
+            pins << Solargraph::Pin::DelegatedMethod.new(
+              closure: ns,
+              scope: :instance,
+              name: [prefix, method_name].select(&:itself).join("_"),
+              node: meth,
+              receiver: chain,
+              receiver_method_name: method_name.to_s,
+            )
           end
         end