Skip to content
CAI
Software that uses CAICheck a score

castwide/solargraph

60.7

Adequate · 6 November 2026

24.5k

lines of production code

Ruby

primary language

4

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add internal HTML documentation and environment views

Solargraph now includes a set of internal ERB templates to render HTML pages for method documentation, namespace overviews, search results, and environment diagnostics. Users can view detailed method signatures, parameters, return types, and examples via the new document view, browse class/instance methods in namespace views, and access a diagnostic page showing Ruby, RuboCop, and Solargraph configuration details.

lib/solargraph/views · high confidence

Added RBS type definitions for Bundler, Open3, RubyGems, AST, Parser, Diff-LCS, and Thor

This release adds comprehensive RBS type signatures for several Ruby standard libraries and common gems to improve static analysis and IDE support. The \rbs/fills\ directory now includes type definitions for the \Bundler\ module, \Open3\ process management methods, and core \RubyGems\ classes such as \Specification\, \Dependency\, \BasicSpecification\, \SpecFetcher\, and error types. Additionally, \rbs/shims\ provides type stubs for the \ast\ gem (including \Node\ and \Processor\), the \parser\ gem (covering \Base\, \Builders::Default\, \Source\ classes, and version-specific parsers like \Ruby32\), \diff-lcs\ (for \LCS\, \diff\, and \patch!\), and \thor\ (including \Thor.start\ and \Actions::CreateFile\). These files enable type checking for code interacting with these libraries.

rbs · high confidence

Implement workspace message handlers for configuration, file watching, and symbol search

Solargraph now handles key LSP workspace notifications and requests. The \didChangeConfiguration\ handler updates the host with new settings and dynamically registers or unregisters server capabilities (such as completion, hover, formatting, and symbols) based on those options. The \didChangeWatchedFiles\ handler processes file creation, modification, and deletion events, updating the host's file state and forcing a catalog refresh when necessary to keep library definitions accurate. The \didChangeWorkspaceFolders\ handler manages the addition and removal of workspace folders. Additionally, the \workspace/symbol\ request is implemented to search for symbols across the entire workspace, returning their names, containers, kinds, locations, and deprecation status.

_lib/solargraph/language\server/message/workspace · high confidence

Initial language server protocol implementation

Solargraph now includes a full Language Server Protocol (LSP) implementation, enabling IDEs and editors to integrate with the tool for features like code completion, diagnostics, hover information, and go-to-definition. This change introduces the core \Host\ class to manage workspace state and client communication, a \Message\ registry to handle LSP method routing, and supporting modules for progress notifications, URI handling, and protocol constants.

_lib/solargraph/language\server · high confidence

Introduce structured caching and pin collection system

Solargraph now includes a dedicated caching infrastructure to store and retrieve type pins more efficiently. New modules like \CacheDir\ manage versioned cache directories for YARD, RBS, and Solargraph data, while the \Collection\ namespace provides a framework for caching core, gem, stdlib, and RBS pins. This system serializes pins to disk and caches them in memory, reducing redundant parsing and improving startup and cataloging performance for large projects.

lib/solargraph · high confidence

New RBS-based type mapping system

Solargraph introduces a new \RbsMap\ module to convert RBS type definitions into internal pins, providing more accurate type information for Ruby core, stdlib, and gems. This system includes dedicated classes for loading core and stdlib types, handling gem dependencies, and converting RBS declarations into Solargraph's internal representation, with fallback mechanisms to fill gaps in RBS coverage.

_lib/solargraph/rbs\map · high confidence

New YardMap implementation with macro support and caching

Solargraph introduces a new internal YardMap architecture that adds support for YARD macros (e.g., @!method, @!attribute) and the @!scope directive, allowing DSL-generated methods to be properly recognized. It also includes a new caching mechanism for YARD pin queries to improve performance, and fixes a bug where YARD's handling of open singleton classes could incorrectly override constant pins.

_lib/solargraph/yard\map · high confidence

New diagnostics reporters for linting, type checking, and require resolution

Solargraph now includes a new diagnostics framework with reporters for RuboCop linting, strict type checking, unresolved requires, and syntax errors. The RuboCop reporter runs linting inline via the RuboCop API, mapping RuboCop severities to LSP diagnostic levels and handling configuration and drive-letter fixes. The TypeCheck reporter identifies undefined return types, untagged parameters, and invalid param tags, with configurable strictness levels. RequireNotFound reports paths that cannot be resolved to workspace files or gems, and UpdateErrors surfaces syntax errors by combining source error ranges. These reporters provide structured, LSP-compliant diagnostics directly within the editor.

lib/solargraph/diagnostics · high confidence

New extended LSP methods for documentation, search, and environment info

Solargraph now exposes several new custom LSP methods under the $/solargraph/ namespace to enhance IDE integration. Users can now request rendered HTML documentation for symbols ($/solargraph/document), perform full-text search with rendered results ($/solargraph/search), and view a detailed environment report including RuboCop version and workspace folders ($/solargraph/environment). Additionally, the server supports updating gem documentation ($/solargraph/documentGems), checking for Solargraph gem updates with optional in-place upgrades ($/solargraph/checkGemVersion), and a deprecated handler for core documentation downloads ($/solargraph/downloadCore).

_lib/solargraph/language\server/message/extended · high confidence

New reference pin types for Ruby language constructs

Solargraph introduces a new set of pin classes under \lib/solargraph/pin/reference\ to represent specific Ruby language constructs, including \Extend\, \Include\, \Prepend\, \Require\, \Superclass\, \TypeAlias\, and \Override\. These pins allow the language server to more accurately model and track references to module extensions, class inclusions, method overrides, type aliases, and other structural relationships, improving the precision of type checking and navigation for these features.

lib/solargraph/pin/reference · high confidence

New workspace configuration and require path resolution

Solargraph introduces a dedicated configuration class (lib/solargraph/workspace/config.rb) that manages workspace settings via .solargraph.yml and a global config file, including defaults for included/excluded files, reporters, and type checker rules. It also adds a RequirePaths class (lib/solargraph/workspace/require\_paths.rb) that automatically determines library load paths by parsing gemspec files or using configured paths, improving how Solargraph discovers and indexes project dependencies.

lib/solargraph/workspace · high confidence

Support for YARD DSL directives in the YardMap

The YardMap now processes several YARD \@!\ directives to generate or modify type information. It supports \@!method\ and \@!attribute\ to define synthetic methods and accessors, \@!parse\ to embed and parse Ruby code snippets for additional definitions, \@!scope\ to enforce class or instance scope on following methods, \@!visibility\ to set public/protected/private visibility, \@!override\ to mark method overrides, and \@!domain\ to assign namespace domains.

_lib/solargraph/yard\map/directives · high confidence

Architecture

Refactor YARD map mappers into dedicated modules

The YARD map mapper logic has been restructured from monolithic classes into separate modules (ToConstant, ToMethod, ToNamespace). This change extracts the creation of Constant, Method, and Namespace pins into distinct files, improving code organization and maintainability without altering the resulting pin data or user-facing behavior.

_lib/solargraph/yard\map/mapper · high confidence

Refactored LSP message handling into a modular class structure

The language server's message handling has been reorganized from a monolithic structure into distinct classes within the \lib/solargraph/language\_server/message\ directory. A new \Base\ class centralizes request parsing, response formatting, and cancellation logic, while specific LSP methods (such as \initialize\, \completion\, \hover\, and \shutdown\) are now handled by dedicated subclasses. This change improves code maintainability and clarifies how the server processes individual protocol requests and notifications.

_lib/solargraph/language\server/message · high confidence

Refactored text document message handlers into a modular class structure

The text document message handlers have been reorganized into a dedicated directory structure under \lib/solargraph/language\_server/message/text\_document/\. A new \Base\ class centralizes URI-to-filename conversion, while individual handlers for LSP methods (such as \completion\, \definition\, \hover\, \formatting\, \rename\, and \references\) are now distinct classes. This change improves code maintainability and isolation for each LSP feature without altering the external API behavior.

_lib/solargraph/language\_server/message/text\document · high confidence

Behavioural changes

12 commits (0 fixes) modifying lib/solargraph/plugin

A change to existing behaviour in lib/solargraph/plugin — 12 commits, 4 files: “Plugin API changes”; “Removed plugin server process cruft”; “Plugin responses with error handling”; and 9 more (refs \#1435, \#185).

lib/solargraph/plugin · medium confidence · unverified

17 commits (0 fixes) modifying lib/solargraph/convention

A change to existing behaviour in lib/solargraph/convention — 17 commits, 4 files: “Convention and Environ docs”; “Conventions add pins instead of overrides”; “V0.39 (\#311)”; and 14 more (refs \#311, \#1004, \#948, \#622, \#877, …).

lib/solargraph/convention · medium confidence · unverified

Asynchronous diagnosis and threaded message handling

Solargraph now runs diagnostics asynchronously via a dedicated background thread (Host::Diagnoser) that processes a queue of file URIs, improving responsiveness by preventing blocking during analysis. Incoming LSP messages are now handled by a serial worker thread (Host::MessageWorker) that prioritizes document updates and cancellation requests, ensuring that state-changing operations are processed in order and stale requests can be cancelled. The Host::Sources class manages open file states and notifies observers of changes, while Host::Dispatch handles associating sources with libraries and triggering the new asynchronous diagnosis workflow.

_lib/solargraph/language\server/host · high confidence

Completion item resolution now merges documentation from multiple pins

The completionItem/resolve handler has been refactored to aggregate documentation from multiple pins rather than relying on a single source. When resolving a completion item, the system now combines documentation strings from all relevant pins, deduplicates links (respecting the enablePages option), and formats the final content as Markdown. This results in richer, more comprehensive documentation for completion items in the editor.

_lib/solargraph/language\_server/message/completion\item · high confidence

Introduce SourceMap::Clip for cursor-based completion and type inference

Solargraph now uses the new SourceMap::Clip class to handle completion, type inference, and signature resolution based on the cursor's position. This change replaces the previous fragment-based approach with a more robust mechanism that correctly handles block rebinding, local variable scoping, and constant context, resulting in more accurate autocompletion and type checking for users.

_lib/solargraph/source\map · high confidence

Introduces structured transport layer with JSON-RPC data parsing

Solargraph now includes a dedicated transport layer consisting of an Adapter and a DataReader. The Adapter manages the lifecycle of the language server host and delegates incoming data to the DataReader, which handles the parsing of raw JSON-RPC messages from the client stream. This change replaces previous ad-hoc handling with a structured approach that buffers data, parses JSON payloads, and routes them to the host for processing, while also logging parse errors.

_lib/solargraph/language\server/transport · high confidence

Introduction of base NodeProcessor class for AST parsing

A new base class, Solargraph::Parser::NodeProcessor::Base, has been added to the parser infrastructure. This class provides a standardized foundation for processing Ruby AST nodes, managing context such as source regions, existing pins, and local variables. It introduces methods for traversing child nodes and locating specific pin types (such as breakables, compound statements, and closures) within the current scope, enabling more consistent and maintainable node processing logic across the parser.

_lib/solargraph/parser/node\processor · high confidence

Major library restructuring and new core components

The Solargraph library has undergone a significant structural overhaul, replacing the minimal entry point with a comprehensive module that defines numerous new error classes (such as ComplexTypeError and WorkspaceTooLargeError) and expands the autoload registry to include many new subsystems like RbsMap, TypeChecker, and Logging. This change introduces support for inline RBS and RBS translation, adds a new Bench module, and implements a mutex-based mechanism to prevent overlapping chdir calls in multi-threaded environments. Additionally, the library now enforces UTF-8 encoding by default and includes a compatibility shim for Bundler's environment handling methods.

lib · high confidence

New parser subsystem with flow-sensitive typing and comment ripper

Solargraph introduces a new parser implementation in lib/solargraph/parser that replaces the legacy RubyVM parser. This new system includes a CommentRipper for extracting comments, a Region class for tracking source context, and a NodeProcessor for generating pins. A key feature is FlowSensitiveTyping, which automatically refines variable types based on control flow (such as \is\_a?\ checks, \nil?\ checks, and \if\/\while\ conditions), providing more accurate type information for users.

lib/solargraph/parser · high confidence

New parser-gem node processors for AST handling

The parser-gem node processors have been rewritten to use the \parser\ gem's AST node types directly, replacing the previous internal node handling. This change introduces dedicated processors for various Ruby syntax elements, including method definitions (\def\/\defs\), control flow (\if\, \while\, \until\, \resbody\), variable assignments (local, instance, class, global, and mass assignments), and module/class structures (\namespace\, \sclass\). It also adds support for inline RBS superclass parameters, flow-sensitive typing for logical operators (\and\/\or\), and improved handling of method visibility and attribute generation.

_lib/solargraph/parser/parser\_gem/node\processors · high confidence

New source synchronization and type inference architecture

Solargraph introduces a new internal architecture for handling source code changes and type inference, replacing the previous fragment-based system with Chains, Clips, and Cursors. This change improves the accuracy of type inference and completion in unsynchronized or repaired source buffers by using a new \SourceChainer\ that can parse and chain nodes from fixed phrases. It also adds a \Source::Change\ class to manage text updates and repairs, and a \Cursor\ class to track position and word context, resulting in more robust handling of partial edits and syntax errors during coding.

lib/solargraph/source · high confidence

New type-checking rule levels and problem reporting structure

The type checker now supports configurable strictness levels (normal, typed, strict, strong, alpha) that can be adjusted per rule in .solargraph.yml, allowing users to fine-tune which checks are enforced. Additionally, type-checking problems are now reported via a dedicated Problem class that includes location, message, pin, and suggestion details, providing more context for each issue.

_lib/solargraph/type\checker · high confidence

Refactored ApiMap internals with new caching and indexing structures

The ApiMap subsystem has been restructured to improve performance and maintainability. A new ApiMap::Cache class has been introduced to store and retrieve method, constant, and qualified namespace lookups, reducing redundant computation. The ApiMap::Index class now centralizes pin cataloging, providing optimized hashes for namespaces, paths, and class-based lookups, along with support for macro and override mapping. Additionally, the ApiMap::Store class manages multiple pinsets (core, gem, convention, workspace) and synchronizes updates efficiently, while the ApiMap::Constants class handles complex constant resolution and qualification. The ApiMap::SourceToYard module has been updated to generate YARD code objects from pins, ensuring accurate documentation and method visibility.

_lib/solargraph/api\map · high confidence

Refactored pin architecture with new base classes and mixins

The pin system has been restructured to improve type inference and code organization. A new \Pin::Base\ class introduces a \combine\_priority\ attribute to control how pins from different sources (code, YARD, RBS) are merged, allowing higher-priority definitions to override others. \Pin::BaseVariable\ now supports mass assignments and flow-sensitive typing via \intersection\_return\_type\ and \exclude\_return\_type\ parameters. New classes like \Pin::DelegatedMethod\ enable dynamic method aliasing by resolving receivers at runtime, while \Pin::FactoryParameter\ captures literal values for factory method arguments. The \Pin::Documenting\ module now uses Kramdown and ReverseMarkdown for consistent documentation formatting, and \Pin::Block\ includes improved logic for destructure yield types and dynamic rebinding.

lib/solargraph/pin · high confidence

The internal type inference engine for \lib/solargraph/source/chain\ has been restructured from a monolithic implementation into a modular system of distinct link classes. This change introduces specific handlers for different Ruby language constructs, including \Chain::Call\ for method invocations, \Chain::Constant\ for namespace resolution, \Chain::Literal\ for value types, and specialized links for variables (\InstanceVariable\, \ClassVariable\, \GlobalVariable\), control flow (\If\, \Or\), and blocks (\BlockSymbol\, \BlockVariable\). By delegating resolution logic to these dedicated components, the system now provides more granular and accurate type inference for complex code patterns, such as distinguishing between safe navigation operators (\QCall\) and standard calls, or correctly resolving union types in conditional branches.

lib/solargraph/source/chain · high confidence

Refactored type system internals for improved strict checking and generics support

The internal type-checking engine has been restructured to support more robust strict type checking, including better handling of generics, mixins, and union types. A new Conformance class now manages type compatibility checks with support for variance (invariant, covariant, contravariant) and specific rules for interface matching and parameter stripping. The UniqueType class has been enhanced to better parse and represent parameterized types (like Hash and Array generics) and literal types, while TypeMethods provides shared functionality for accessing type data. These changes improve the accuracy of type inference and signature selection, particularly for complex generic scenarios and mixin inclusions.

_lib/solargraph/complex\type · high confidence

Renamed main executable and removed deprecated bin scripts

The main command-line entry point has been renamed from 'solargraph-ruby' to 'solargraph', with the script updated to suppress Ruby warning diagnostics. Additionally, several deprecated utility scripts located in the bin directory have been removed: 'resolve-gem.rb', 'resolve-require.rb', 'solargraph-live-parse', 'stub-current.rb', and 'stub-require.rb'.

bin · high confidence

Standardize development environment and CI quality gates

The project now enforces consistent line endings (LF) for Ruby and binary files via .gitattributes and normalizes existing line endings. Development workflows are standardized with new configuration files: .envrc sets the Solargraph version based on the current git branch, .overcommit.yml enables RuboCop and Solargraph checks on pre-commit (excluding specs), and .rubocop.yml sets the target Ruby version to 3.1, enables new cops, and configures specific style and metric thresholds. The Rakefile has been significantly expanded to include dedicated tasks for running the type checker at various strictness levels (typed, strict, strong, alpha), a comprehensive test suite with coverage reporting via Undercover and SimpleCov, and quality checks using Overcommit.

(repo-wide) · high confidence

Support for HTML definition lists and inline code in Markdown conversion

Solargraph now correctly converts HTML definition lists (\<dl\>, \<dt\>, \<dd\>) and inline code (\<tt\>) back into Markdown format. New converters handle the specific formatting requirements for definition terms, descriptions, and the list container, while the \<tt\> tag is mapped to the existing code converter to ensure consistent inline code representation.

lib/solargraph/converters · high confidence

Switch to Prism-based parsing in the parser gem adapter

The parser gem adapter now uses Prism (via prism-translation-parser) instead of the legacy RubyVM parser to parse Ruby source code. This change introduces new internal components (ClassMethods, FlawedBuilder, NodeChainer, NodeMethods, and NodeProcessors) to handle AST generation, comment extraction, and node processing, enabling better support for modern Ruby syntax and improving type-checking accuracy.

_lib/solargraph/parser/parser\gem · high confidence

Test coverage

1 commit adding/updating tests in spec/parser/parser\_gem; Added RDoc fixture for testing documentation conversion; Added comprehensive test coverage for Solargraph Pin classes; Added comprehensive test coverage for Solargraph core components; Added parser test coverage for flow-sensitive typing, node chaining, and node processing; Added test coverage for ApiMap components; Added test coverage for RBS map conversions, core, gem, and stdlib handling; Added test coverage for SourceMap components; Added test coverage for diagnostics subsystem; Added test coverage for textDocument LSP messages; Added test coverage for the language server host, protocol, and URI helpers; Added test coverage for type checker strictness levels; Added test fixture for RuboCop unused variable error; Added test fixtures for YARD map edge cases; Added test fixtures for edge-case parsing scenarios; Added test fixtures for external gem dependencies; Added test fixtures for workspace folders; Added tests for CheckGemVersion message handling; Added tests for Language Server initialization capabilities; Added tests for Solargraph::YardMap::Mapper; Added tests for Workspace::Config and RequirePaths; Added tests for YARD method parameter mapping; Added tests for completion item resolve behavior; Added tests for language server host components; Added tests for language server transport adapter and data reader; Added tests for source analysis components; Added tests for type checker rule configurations; Added tests for workspace configuration and file watching handlers; Added unit tests for Source::Chain components.

Dependencies

Solargraph 0.1.0: Major dependency overhaul and Ruby 3.1 requirement

Solargraph has been updated to version 0.1.0, introducing a comprehensive rewrite of its gemspec that significantly expands and tightens runtime dependencies. The minimum supported Ruby version is now 3.1, reflecting a shift away from older Ruby versions. Key dependency changes include the adoption of the \prism\ parser (\~\> 1.4) alongside the existing \parser\ gem, the use of \kramdown\ (\~\> 2.3) for Markdown processing, and updated constraints for \rbs\ (\>= 3.10.4), \rdoc\ (\~\> 7.0), \rubocop\ (\~\> 1.76), and \thor\ (\~\> 1.0). The gem also adds several new dependencies such as \backport\, \benchmark\, \diff-lcs\, \jaro\_winkler\, \logger\, \observer\, \open3\, \ostruct\, \sord\, \tilt\, and various YARD plugins (\yard-activesupport-concern\, \yard-solargraph\). Development dependencies have also been updated, including specific RuboCop plugins and testing tools. Additionally, the gemspec now uses \git ls-files\ to dynamically determine included files and includes metadata for funding, bug tracking, and changelog URIs.

(dependencies) · high confidence

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

How this codebase got here

Score

  • CAI 62 → 61 (-1.4)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.2) — scores are not directly comparable.

Lenses

  • Code Health 71 → 65 (-5.4)
  • Architecture 89 → 88 (-1.5)
  • Maturity 54 → 54 (+0.0)
  • Readiness 70 → 70 (+0.0)
  • Security 77 → 65 (-11.6)
  • Accessibility 65 → 65 (+0.0)

Resolved (9)

  • Ambiguous naming for method resolution. 'get_methods' and 'get_method_stack' appear to perform similar lookups but with different return structures or depth handling. Without documentation, it is unclear if 'stack' implies inheritance resolution while 'methods' implies direct definition, or if they are redundant.
  • Duplicated block (10 lines × 2) (lib/solargraph/convention/data_definition/data_assignment_node.rb)
  • Duplicated block (10 lines × 2) (lib/solargraph/parser/parser_gem/node_processors/cvasgn_node.rb)
  • Duplicated block (5 lines × 2) (lib/solargraph/convention/data_definition/data_assignment_node.rb)
  • Duplicated block (5 lines × 3) (lib/solargraph/convention/data_definition/data_assignment_node.rb)
  • Duplicated block (5 lines × 3) (lib/solargraph/rbs_map/conversions.rb)
  • Hotspot: lib/solargraph/type_checker.rb (lib/solargraph/type_checker.rb)
  • Method name collision across related types with potentially different semantics. 'get_methods' exists on ApiMap, its Cache, and its Store. While this might be intentional delegation, it creates a confusing surface where the same name behaves differently depending on the layer (cache miss vs direct store access vs full resolution).
  • Typo in class name: 'Defintion' instead of 'Definition'. This creates an inconsistent naming pattern compared to other classes like 'ClassDefinition' and 'DataDefinition'.

New (10)

  • ActiveSupport.generate_call_pins (cognitive 25) (lib/solargraph/plugin/active_support.rb)
  • ActiveSupport.generate_call_pins (cyclomatic 20) (lib/solargraph/plugin/active_support.rb)
  • Change coupling: api_map.rb ↔ base.rb (lib/solargraph/api_map.rb)
  • DeepInference.from_value_position_statement (cognitive 19) (lib/solargraph/parser/parser_gem/node_methods.rb)
  • Duplicated block (10 lines × 2) (lib/solargraph/parser/parser_gem/node_processors/data_definition/data_assignment_node.rb)
  • Duplicated block (5 lines × 2) (lib/solargraph/parser/parser_gem/node_processors/data_definition/data_assignment_node.rb)
  • Duplicated block (5 lines × 3) (lib/solargraph/parser/parser_gem/node_processors/casgn_node.rb)
  • Hotspot: lib/solargraph/rbs_translator.rb (lib/solargraph/rbs_translator.rb)
  • TooManyMethods: SourceMap (lib/solargraph/source_map.rb)
  • UniqueType.parse (cyclomatic 16) (lib/solargraph/complex_type/unique_type.rb)

Changes since last survey

  • 29 commits — 27 feature/other, 2 fixes

By area

  • lib/solargraph — 24 commits
  • (root) — 2 commits
  • rbs/fills — 1 commit
  • spec/language_server — 1 commit
  • spec/source_map — 1 commit

Notable commits

  • fix: [regression fix] Cache gems that have a leftover YARD lock (#1465)
  • fix: [regression fix] Stop rerunning a gem cache command that failed (#1442)
  • change: Always report completion for workspace mapping progress (#1475)
  • change: Apply @!override to constants instead of crashing (#1305)
  • change: Apply mixins from self.included hooks to includers (#1405)
  • change: Bind reopened generic parameters by position (#1411)
  • change: Close attribute directives over their namespace (#1432)
  • change: Default anonymous type shorthand names (#1454)
  • change: Define Boolean so its operators resolve (#1351)
  • change: Enable pending clip spec (#1462)
  • change: Improved RBS type alias support (#1281)
  • change: Keep the adapter spec from hanging in Backport.run (#1449)
  • change: Keep the generic return type when a method takes a block (#1274)
  • change: Move Class, Struct, and Data definition processors to NodeProcessors (#1468)
  • change: New Plugin architecture with ActiveSupport implementation (#1435)
  • change: Preserve immutable completion item properties during resolve (#1471)
  • change: Release 0.62.0
  • change: Release 0.62.1
  • change: Remove Convention::ActiveSupportConcern (#1469)
  • change: Remove Dispatch#update's hidden assumption that self is a Host (#1440)
  • …and 9 more

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

Survey your own repository

castwide/solargraph was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.

About this page

  • The score is its most recent published measurement, taken on 6 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit 42ac0f358878b90f482abacc0ecbe9ee8a390063 — the exact code this score is about.
  • Scored under rubric-2026.11.2 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.2+preprod-5c4e66d9318b.