solargraph-dr_talon 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 59cb25b83626aa02916b35bc21ed7b4fcd4b79e0c524d722a65f46230cd75b19
+  data.tar.gz: 488e29552652a04a9b00e04a89ae975ecac5736ab8c79b20c5271f65d064083f
+SHA512:
+  metadata.gz: 21b155a0758aea291a38904e988631650489041d48cbc0dc06886d811c2bf9266af5e5b9c80cc568375b238fda66239731bf01d7c286c9447b517596f2bd48d8
+  data.tar.gz: a2fd60d16ce640bec21a5b77a4c2411f305a1b7e95567a5d65eff8b4fa42b231ba898fb3aca8965735d59bc0dcc6109e3b37cb710b9804ecf75885b3fe6c010c

data/CHANGELOG.md

@@ -0,0 +1,17 @@
+## [Unreleased]
+
+## [0.1.0] - 2026-10-11
+
+- Initial release: a Solargraph plugin for the [Talon](https://github.com/asimmons91/talon) game framework.
+- `Talon::Concern` mixins: methods in a `class_methods do ... end` block are defined in the concern's `ClassMethods`
+  module, and including or prepending a concern (or a class whose superclass did) adds them, and those of the
+  concerns it includes, to the host's class methods. Inside `included do ... end`, `self` gets the concern's own
+  class methods and those of the concerns it includes.
+- `prop` and `state` declarations define reader and writer methods, typed by a `@return` tag above the call or
+  inferred from a literal `default:`. Declarations in a concern's `included` block belong to the concern.
+- Lifecycle hook blocks in a class body (`on_start`, `on_update`, `on_draw`, `on_destroy`, `on_enter`, `on_exit`,
+  any other `on_*`, `set_callback` and `define_callback`) are evaluated on the instance. Their block parameters
+  are typed by the hook method's `@yieldparam` tag, which Talon's built-in hooks document as `GTK::Args`.
+
+[Unreleased]: https://github.com/asimmons91/solargraph-dr_talon/compare/v0.1.0...HEAD
+[0.1.0]: https://github.com/asimmons91/solargraph-dr_talon/releases/tag/v0.1.0

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,10 @@
+# Code of Conduct
+
+"solargraph-dr_talon" follows [The Ruby Community Conduct Guideline](https://www.ruby-lang.org/en/conduct) in all "collaborative space", which is defined as community communications channels (such as mailing lists, submitted patches, commit comments, etc.):
+
+* Participants will be tolerant of opposing views.
+* Participants must ensure that their language and actions are free of personal attacks and disparaging personal remarks.
+* When interpreting the words and actions of others, participants should always assume good intentions.
+* Behaviour which can be reasonably considered harassment will not be tolerated.
+
+If you have any concerns about behaviour within this project, please contact us at ["austin_simmons@fastmail.com"](mailto:"austin_simmons@fastmail.com").

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Austin Simmons
+
+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,149 @@
+# solargraph-dr_talon
+
+A [Solargraph](https://solargraph.org) plugin that gives LSP editors autocomplete, hover docs and go-to-definition
+for games built with [Talon](https://github.com/asimmons91/talon), a scene/game object/component framework for
+[DragonRuby](https://dragonruby.org).
+
+Solargraph already indexes Talon's source when it's in your game. This plugin teaches it the parts of Talon that
+are defined by metaprogramming:
+
+```ruby
+class Mover < Talon::Component
+  prop :speed, default: 2             # speed / speed= (Integer), from prop and state
+  state :x, default: 0                # prop, state, on_update, ... complete in the class body
+
+  on_update do |args|                 # hook blocks run on the instance: self is a Mover
+    self.x += speed                   # so props, state, go, scene and attr_dr helpers complete
+    args.outputs.sprites << { ... }   # args is GTK::Args in Talon's built-in hooks
+  end
+end
+
+module Visible
+  extend Talon::Concern
+  include Talon::Configurable
+
+  included do
+    prop :visible, default: true      # Lamp.new.visible completes
+  end
+
+  class_methods do
+    def hidden_by_default             # Lamp.hidden_by_default completes
+      prop_defaults[:visible] = false
+    end
+  end
+end
+
+class Lamp < Talon::Component
+  include Visible
+end
+```
+
+## Requirements
+
+- A CRuby install. DragonRuby doesn't need one, but Solargraph does.
+- Solargraph 0.61.x: `gem install solargraph -v '~> 0.61.0'`
+- Talon's source in your Solargraph workspace, for example vendored in `mygame/lib/talon`. Vendor Talon from
+  commit 6625c07 or later so hook block parameters are typed as `GTK::Args`.
+- [solargraph-dragonruby](https://github.com/asimmons91/solargraph-dragonruby), recommended, for the DragonRuby
+  API (`args`, `outputs`, `attr_dr`, ...). This plugin works without it, but `args`, `outputs` and the other
+  DragonRuby helpers won't complete.
+
+## Installation
+
+Install the gems into the same Ruby that runs `solargraph`:
+
+```sh
+gem install solargraph-dragonruby solargraph-dr_talon
+```
+
+Then add both plugins to the `.solargraph.yml` in your game's root directory (`solargraph config` generates a
+default one), and make sure `include` covers Talon's source:
+
+```yml
+include:
+  - "mygame/**/*.rb"
+plugins:
+  - solargraph-dragonruby
+  - solargraph-dr_talon
+```
+
+Restart your editor's language server. See solargraph-dragonruby's README for editor setup.
+
+## What's covered
+
+- **`Talon::Concern`**
+  - Methods in a `class_methods do ... end` block are defined in the concern's `ClassMethods` module, which is how
+    they exist at runtime.
+  - Including or prepending a concern adds its class methods to the host, along with those of every concern it
+    includes (its dependencies). Subclasses inherit them, so `prop`, `state`, `set_callback`, `prop_defaults`, ...
+    complete in any subclass of `Talon::Component`, `Talon::Scene`, `Talon::GameObject` or `Talon::Game`.
+  - Inside `included do ... end` (and `prepended do ... end`), `self` is the class that includes the concern, which
+    can't be known statically. So the concern's own class methods and those of the concerns it includes complete
+    there. To use `prop` in an `included` block, have the concern `include Talon::Configurable` (for `state`,
+    `Talon::Stateful`, and for `on_*` hooks, `Talon::Callbacks`). Talon then also includes them into the host.
+- **`prop` and `state`** define a reader and a writer.
+  - The type comes from a `@return` tag in the comment above the call, or is inferred from a literal `default:`
+    (`2` is an `Integer`, `"a"` a `String`, `true` a `Boolean`, `Vector.new(...)` a `Vector`, ...).
+  - The comment becomes the hover docs, and go-to-definition jumps to the declaration.
+  - A declaration in a concern's `included` block defines the methods on the concern, so every host gets them.
+- **Lifecycle hook blocks** in a class body are evaluated on the instance, as Talon runs them.
+  - This applies to `on_start`, `on_update`, `on_draw`, `on_destroy`, `on_enter` and `on_exit`, and to `set_callback`
+    and `define_callback`.
+  - It also covers any other `on_*` call, so custom hooks (`def self.on_hit(&b) = set_callback(:hit, &b)`) work
+    too.
+  - Block parameters are typed by the hook method's `@yieldparam` tag. Talon's built-in hooks document theirs as
+    `GTK::Args` (since Talon 6625c07; older copies leave `args` untyped). Document a custom hook the same way:
+
+    ```ruby
+    # @yieldparam enemy [Enemy]
+    def self.on_hit(*method_names, &block) = set_callback(:hit, *method_names, &block)
+    ```
+
+### Limitations
+
+- The plugin recognizes Talon's DSLs by name, so it doesn't check that a class actually descends from a Talon
+  class:
+  - `prop :name` and `state :name` called in any class body define accessors.
+  - A block passed to any bare `on_*` call in a class body is evaluated on the instance.
+- A concern's own class side (`Visible.hidden_by_default`) also completes its `ClassMethods`. This is what makes
+  them complete inside `included do ... end`, but calling them on the concern itself fails at runtime.
+- The Talon methods behind a hook block (such as `update` from `on_update`) are generated at runtime and don't
+  complete.
+
+## Development
+
+```sh
+bin/setup                         # install dependencies
+bundle exec rake                  # tests + standardrb
+bundle exec rake fixtures:sync    # re-vendor Talon's lib/ into test/fixtures from main
+bundle exec rake fixtures:sync[<ref>] # ...or from a specific branch, tag or commit
+```
+
+- `test/fixtures/talon` is a snapshot of Talon's `lib/` that the tests run against. `UPSTREAM` records its commit.
+  After a Talon change, sync it and re-run the tests.
+- The Solargraph dependency is pinned to `~> 0.61.0`, because the node processor and convention internals this
+  plugin hooks into change between minor releases. Re-run the tests before widening it.
+
+### Releasing
+
+Add changes to the `## [Unreleased]` section of `CHANGELOG.md` as you go. To release:
+
+```sh
+bundle exec rake release:prepare[minor]   # or major, patch, or an explicit version like 1.2.3
+git push origin main v0.2.0               # the command it prints
+```
+
+`release:prepare` runs the tests, bumps `version.rb` and `Gemfile.lock`, moves the Unreleased notes under a
+dated heading, and commits and tags the release. The first release can use the current version:
+`rake release:prepare[0.1.0]`. Pushing the tag runs `.github/workflows/release.yml`. It checks that the tag,
+version and changelog agree, publishes the gem to RubyGems.org with
+[Trusted Publishing](https://guides.rubygems.org/trusted-publishing/), and creates the GitHub release from that
+version's changelog notes.
+
+One-time setup: on RubyGems.org, add a trusted publisher for this repository with the workflow `release.yml` and
+the environment `release`. The gem has never been pushed, so add it as a "pending" trusted publisher.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+The vendored Talon source in `test/fixtures/talon` is also MIT licensed, by Austin Simmons.

data/Rakefile

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "minitest/test_task"
+
+Minitest::TestTask.create do |t|
+  # Solargraph and its dependencies emit many -w warnings on Ruby 4.0.
+  t.warning = false
+end
+
+require "standard/rake"
+
+task default: %i[test standard]

data/lib/solargraph/dr_talon/attribute_node.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module DrTalon
+    # Maps Talon's attribute DSLs to reader and writer pins:
+    #
+    #   prop :speed, default: 2    # Talon::Configurable
+    #   state :score, default: 0   # Talon::Stateful
+    #
+    # A `@return` tag in the comment above the call sets the type; otherwise
+    # it's inferred from a literal `default:`.
+    #
+    # This is a node processor rather than a Convention#local because
+    # Solargraph 0.61 doesn't notice when a file's convention pins change, so
+    # adding or removing a declaration wouldn't take effect until a restart.
+    class AttributeNode < Solargraph::Parser::NodeProcessor::Base
+      DSLS = {
+        prop: "Talon prop",
+        state: "Talon state value, stored in `args.state`"
+      }.freeze
+
+      # Literal node types and the type of the value they produce.
+      LITERAL_TYPES = {
+        int: "Integer",
+        float: "Float",
+        rational: "Rational",
+        str: "String",
+        dstr: "String",
+        sym: "Symbol",
+        dsym: "Symbol",
+        # standard:disable Lint/BooleanSymbol -- these are AST node types
+        true: "Boolean",
+        false: "Boolean",
+        # standard:enable Lint/BooleanSymbol
+        array: "Array",
+        hash: "Hash",
+        irange: "Range",
+        erange: "Range"
+      }.freeze
+
+      # Runs after Solargraph's own SendNode, which has already processed the
+      # children, so this only adds the attribute pins.
+      #
+      # @return [Boolean] true, so later :send processors still run
+      def process
+        receiver, dsl, attribute, *options = node.children
+        return true unless receiver.nil? && DSLS.key?(dsl) && attribute&.type == :sym
+
+        host = Host.namespace(region)
+        return true unless host
+
+        name = attribute.children[0].to_s
+        comments = attribute_comments(dsl, options)
+        reader = method_pin(host, name, comments)
+        writer = method_pin(host, "#{name}=", comments)
+        writer.parameters.push Solargraph::Pin::Parameter.new(name: "value", decl: :arg, closure: writer, source: :dr_talon)
+        if reader.return_type.defined?
+          writer.docstring.add_tag YARD::Tags::Tag.new(:param, "", reader.return_type.items.map(&:rooted_tags), "value")
+        end
+        pins.push reader, writer
+        true
+      end
+
+      private
+
+      # @param host [Solargraph::Pin::Namespace]
+      # @param name [String]
+      # @param comments [String]
+      # @return [Solargraph::Pin::Method]
+      def method_pin(host, name, comments)
+        # Talon defines these with attr_accessor and define_method inside its
+        # own methods, so they're public whatever the caller's visibility.
+        Solargraph::Pin::Method.new(
+          location: location,
+          closure: host,
+          name: name,
+          comments: comments,
+          scope: :instance,
+          visibility: :public,
+          attribute: true,
+          source: :dr_talon
+        )
+      end
+
+      # The comment above the call, or a description of the declaration, plus
+      # an inferred `@return` tag if the comment doesn't have one.
+      #
+      # @param dsl [Symbol]
+      # @param options [Array<Parser::AST::Node>]
+      # @return [String]
+      def attribute_comments(dsl, options)
+        comments = comments_for(node).to_s
+        comments = "#{DSLS[dsl]}: `#{region.code_for(node)}`" if comments.strip.empty?
+        return comments if comments.match?(/^\s*@return\b/)
+
+        type = inferred_type(options)
+        type ? "#{comments}\n@return [#{type}]" : comments
+      end
+
+      # @param options [Array<Parser::AST::Node>]
+      # @return [String, nil]
+      def inferred_type(options)
+        default = default_value(options)
+        return unless default
+        return LITERAL_TYPES[default.type] if LITERAL_TYPES.key?(default.type)
+
+        # Foo.new(...)
+        receiver, method = default.children
+        if default.type == :send && method == :new && receiver&.type == :const
+          region.code_for(receiver)
+        end
+      end
+
+      # @param options [Array<Parser::AST::Node>]
+      # @return [Parser::AST::Node, nil]
+      def default_value(options)
+        hash = options.last
+        return unless hash&.type == :hash || hash&.type == :kwargs
+
+        pair = hash.children.find do |child|
+          child.type == :pair && child.children[0].type == :sym && child.children[0].children[0] == :default
+        end
+        pair&.children&.last
+      end
+    end
+  end
+end

data/lib/solargraph/dr_talon/block_node.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module DrTalon
+    # Maps the blocks that Talon evaluates somewhere other than where they're
+    # written, and defers every other block to Solargraph's BlockNode:
+    #
+    # * `class_methods do ... end` in a concern: its methods are defined in the
+    #   concern's `ClassMethods` module (see Talon::Concern#class_methods).
+    # * `included do ... end` and `prepended do ... end` in a concern: `self` is
+    #   the host, so they get the concern's class side (see Convention).
+    # * Lifecycle hook blocks in a class body (`on_update do ... end`, and any
+    #   other bare `on_*`, `set_callback` or `define_callback` call): Talon
+    #   evaluates them on an instance, so `self` is the instance. Block
+    #   parameters are typed by the hook method's own `@yieldparam` tags.
+    class BlockNode < Solargraph::Parser::ParserGem::NodeProcessors::BlockNode
+      # Methods that register a block as an instance callback, besides `on_*`.
+      CALLBACK_METHODS = %i[set_callback define_callback].freeze
+
+      # @return [Boolean] false when this processor mapped the block, so
+      #   later :block processors don't map it again
+      def process
+        call = node.children[0]
+        return super unless call.type == :send && call.children[0].nil?
+
+        name = call.children[1]
+        concern = concern_namespace
+        if name == :class_methods && call.children.length == 2 && concern
+          process_class_methods(concern)
+        elsif Host::CONCERN_BLOCKS.include?(name) && concern
+          process_bound_block("Class<#{concern.path}>", :class, comments_for(node))
+        elsif hook?(name) && (host = Host.namespace(region))
+          process_bound_block(host.path, :instance, comments_for(node))
+        else
+          super
+        end
+      end
+
+      private
+
+      # @return [Solargraph::Pin::Namespace, nil] the module whose body this
+      #   block is in
+      def concern_namespace
+        closure = region.closure
+        closure if region.scope != :class && closure.is_a?(Solargraph::Pin::Namespace) && closure.type == :module
+      end
+
+      # @param name [Symbol]
+      # @return [Boolean]
+      def hook?(name)
+        name.start_with?("on_") || CALLBACK_METHODS.include?(name)
+      end
+
+      # @param concern [Solargraph::Pin::Namespace]
+      # @return [false]
+      def process_class_methods(concern)
+        class_methods = Solargraph::Pin::Namespace.new(
+          type: :module,
+          location: location,
+          closure: concern,
+          name: "ClassMethods",
+          comments: comments_for(node),
+          visibility: :public,
+          gates: concern.gates.freeze,
+          source: :dr_talon
+        )
+        pins.push class_methods
+        body = node.children[2]
+        Solargraph::Parser::NodeProcessor.process(body, region.update(closure: class_methods, visibility: :public), pins, locals, ivars)
+        false
+      end
+
+      # @param context [String] the type of `self` in the block
+      # @param scope [Symbol]
+      # @param comments [String]
+      # @return [false]
+      def process_bound_block(context, scope, comments)
+        block_pin = BoundBlock.new(
+          location: location,
+          closure: region.closure,
+          node: node,
+          context: Solargraph::ComplexType.try_parse(context),
+          receiver: node.children[0],
+          comments: comments,
+          scope: scope,
+          source: :dr_talon
+        )
+        pins.push block_pin
+        process_children region.update(closure: block_pin)
+        false
+      end
+    end
+
+    # A block whose `self` the plugin knows from Talon's semantics. Solargraph
+    # rebinds a block from its method's `@yieldreceiver` tag, but Talon's tags
+    # are generic (Concern#included says `[Class]`), so this keeps the context
+    # it was mapped with.
+    class BoundBlock < Solargraph::Pin::Block
+      # @param _api_map [Solargraph::ApiMap]
+      # @return [void]
+      def rebind(_api_map)
+      end
+    end
+  end
+end

data/lib/solargraph/dr_talon/convention.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module DrTalon
+    # Adds class methods from Talon::Concern mixins. Including a concern
+    # extends the host with the concern's `ClassMethods`, and with those of
+    # every concern it includes (its dependencies).
+    #
+    # Inside a concern, `self` in an `included do ... end` block is the host,
+    # which can't be known statically, so the concern's own class side gets
+    # its `ClassMethods` and its dependencies'.
+    #
+    # Resolved when methods are looked up rather than when files are parsed,
+    # since whether an included module is a concern depends on other files.
+    class Convention < Solargraph::Convention::Base
+      CONCERN = "Talon::Concern"
+
+      # @param api_map [Solargraph::ApiMap]
+      # @param rooted_tag [String]
+      # @param scope [Symbol] :class or :instance
+      # @param visibility [Array<Symbol>]
+      # @param deep [Boolean]
+      # @param skip [Set<String>]
+      # @param _no_core [Boolean]
+      # @return [Solargraph::Environ]
+      def object(api_map, rooted_tag, scope, visibility, deep, skip, _no_core)
+        return EMPTY_ENVIRON unless scope == :class
+
+        rooted_type = Solargraph::ComplexType.parse(rooted_tag).force_rooted
+        fqns = rooted_type.namespace
+        namespace_pin = api_map.get_path_pins(fqns).find { |pin| pin.is_a?(Solargraph::Pin::Namespace) }
+        return EMPTY_ENVIRON unless namespace_pin
+
+        concerns = []
+        concerns << fqns if concern?(api_map, fqns)
+        collect_concerns(api_map, fqns, concerns)
+        return EMPTY_ENVIRON if concerns.empty?
+
+        pins = concerns.flat_map do |concern|
+          api_map.inner_get_methods_from_reference("#{concern}::ClassMethods", namespace_pin, rooted_type,
+            :instance, visibility, deep, skip, true)
+        end
+        Solargraph::Environ.new(pins: pins)
+      end
+
+      private
+
+      # Appends the concerns that `fqns` includes or prepends, and theirs, in
+      # the order Talon includes them into a host.
+      #
+      # @param api_map [Solargraph::ApiMap]
+      # @param fqns [String]
+      # @param concerns [Array<String>]
+      # @return [void]
+      def collect_concerns(api_map, fqns, concerns)
+        mixins(api_map, fqns).each do |ref|
+          mixin = api_map.dereference(ref)
+          next if mixin.nil? || concerns.include?(mixin) || !concern?(api_map, mixin)
+
+          collect_concerns(api_map, mixin, concerns)
+          concerns << mixin
+        end
+      end
+
+      # @param api_map [Solargraph::ApiMap]
+      # @param fqns [String]
+      # @return [Array<Solargraph::Pin::Reference>]
+      def mixins(api_map, fqns)
+        # ApiMap has no public prepend lookup.
+        api_map.get_includes(fqns) + api_map.send(:store).get_prepends(fqns)
+      end
+
+      # @param api_map [Solargraph::ApiMap]
+      # @param fqns [String]
+      # @return [Boolean]
+      def concern?(api_map, fqns)
+        api_map.get_extends(fqns).any? do |ref|
+          # Fall back to the written name when Talon isn't in the workspace.
+          (api_map.dereference(ref) || ref.name.delete_prefix("::")) == CONCERN
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/dr_talon/host.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module DrTalon
+    # Finds the class or module that a Talon class-body DSL call applies to.
+    module Host
+      # Blocks that a Talon::Concern evaluates in the including class. A DSL
+      # call inside one declares on the concern, so its hosts inherit it.
+      CONCERN_BLOCKS = %i[included prepended].freeze
+
+      module_function
+
+      # The namespace whose class body `region` is in, looking through a
+      # concern's `included`/`prepended` block. Nil inside methods, other
+      # blocks, `class << self`, and at the top level.
+      #
+      # @param region [Solargraph::Parser::Region]
+      # @return [Solargraph::Pin::Namespace, nil]
+      def namespace(region)
+        return if region.scope == :class
+
+        closure = region.closure
+        closure = closure.closure if concern_block?(closure)
+        closure if closure.is_a?(Solargraph::Pin::Namespace) && !closure.path.empty?
+      end
+
+      # @param pin [Solargraph::Pin::Base]
+      # @return [Boolean]
+      def concern_block?(pin)
+        return false unless pin.is_a?(Solargraph::Pin::Block) && pin.receiver&.type == :send
+
+        receiver, name = pin.receiver.children
+        receiver.nil? && CONCERN_BLOCKS.include?(name)
+      end
+    end
+  end
+end

data/lib/solargraph/dr_talon/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module DrTalon
+    VERSION = "0.1.0"
+  end
+end

data/lib/solargraph/dr_talon.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "solargraph"
+require_relative "dr_talon/version"
+require_relative "dr_talon/host"
+require_relative "dr_talon/block_node"
+require_relative "dr_talon/attribute_node"
+require_relative "dr_talon/convention"
+
+module Solargraph
+  # Solargraph plugin for the Talon game framework for DragonRuby. Talon itself
+  # is indexed from the game's workspace; this plugin teaches Solargraph the
+  # metaprogramming that static parsing misses.
+  module DrTalon
+  end
+end
+
+Solargraph::Convention.register Solargraph::DrTalon::Convention
+
+# DrTalon::BlockNode handles `class_methods` and hook blocks itself and defers
+# every other block to Solargraph's BlockNode, which it subclasses. It replaces
+# that processor rather than registering beside it, because processors run in
+# registration order and Solargraph's would otherwise map the block first.
+Solargraph::Parser::NodeProcessor.deregister :block, Solargraph::Parser::ParserGem::NodeProcessors::BlockNode
+Solargraph::Parser::NodeProcessor.register :block, Solargraph::DrTalon::BlockNode
+Solargraph::Parser::NodeProcessor.register :send, Solargraph::DrTalon::AttributeNode

data/lib/solargraph-dr_talon.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# Entry point for `.solargraph.yml` `plugins: [solargraph-dr_talon]`,
+# which Solargraph loads with `require "solargraph-dr_talon"`.
+require_relative "solargraph/dr_talon"

data/sig/solargraph/dr_talon.rbs

@@ -0,0 +1,36 @@
+module Solargraph
+  module DrTalon
+    VERSION: String
+
+    module Host
+      CONCERN_BLOCKS: Array[Symbol]
+
+      def self.namespace: (Solargraph::Parser::Region region) -> Solargraph::Pin::Namespace?
+
+      def self.concern_block?: (Solargraph::Pin::Base pin) -> bool
+    end
+
+    class BlockNode < Solargraph::Parser::ParserGem::NodeProcessors::BlockNode
+      CALLBACK_METHODS: Array[Symbol]
+
+      def process: () -> bool
+    end
+
+    class BoundBlock < Solargraph::Pin::Block
+      def rebind: (Solargraph::ApiMap _api_map) -> void
+    end
+
+    class AttributeNode < Solargraph::Parser::NodeProcessor::Base
+      DSLS: Hash[Symbol, String]
+      LITERAL_TYPES: Hash[Symbol, String]
+
+      def process: () -> bool
+    end
+
+    class Convention < Solargraph::Convention::Base
+      CONCERN: String
+
+      def object: (Solargraph::ApiMap api_map, String rooted_tag, Symbol scope, Array[Symbol] visibility, bool deep, Set[String] skip, bool _no_core) -> Solargraph::Environ
+    end
+  end
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification
+name: solargraph-dr_talon
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Austin Simmons
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: solargraph
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.61.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.61.0
+description: 'Teaches Solargraph the metaprogramming in the Talon game framework for
+  DragonRuby: Talon::Concern mixins (class_methods, included), the prop and state
+  DSLs, and on_* lifecycle hook blocks, so LSP editors get autocomplete, hover and
+  go-to-definition in Talon games.'
+email:
+- austin_simmons@fastmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/solargraph-dr_talon.rb
+- lib/solargraph/dr_talon.rb
+- lib/solargraph/dr_talon/attribute_node.rb
+- lib/solargraph/dr_talon/block_node.rb
+- lib/solargraph/dr_talon/convention.rb
+- lib/solargraph/dr_talon/host.rb
+- lib/solargraph/dr_talon/version.rb
+- sig/solargraph/dr_talon.rbs
+homepage: https://github.com/asimmons91/solargraph-dr_talon
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/asimmons91/solargraph-dr_talon
+  changelog_uri: https://github.com/asimmons91/solargraph-dr_talon/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.20
+specification_version: 4
+summary: Solargraph plugin providing Talon game framework completion for DragonRuby
+test_files: []