solargraph-dr_talon 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 59cb25b83626aa02916b35bc21ed7b4fcd4b79e0c524d722a65f46230cd75b19
-  data.tar.gz: 488e29552652a04a9b00e04a89ae975ecac5736ab8c79b20c5271f65d064083f
+  metadata.gz: '0748faad9cf90c06804e66167093ac65dd6f81523d95ead02fd35a0faa462dcd'
+  data.tar.gz: 50ace6eb5d6384c7bd15bc12cda516f3c8b6f24f76298a0fc2cd75588d767a6a
 SHA512:
-  metadata.gz: 21b155a0758aea291a38904e988631650489041d48cbc0dc06886d811c2bf9266af5e5b9c80cc568375b238fda66239731bf01d7c286c9447b517596f2bd48d8
-  data.tar.gz: a2fd60d16ce640bec21a5b77a4c2411f305a1b7e95567a5d65eff8b4fa42b231ba898fb3aca8965735d59bc0dcc6109e3b37cb710b9804ecf75885b3fe6c010c
+  metadata.gz: a8e4fb38812af974a23e7283879ac11de5c73124c48454b5b6167246eb42252f165017195ed78e57babab5dcdf39aed72548b81247eaad8629ccf54b9148dc57
+  data.tar.gz: 29e32ead48c70e1552f09368b8a02180078fec57b346724146780b7957950c951e702b96c8aee5607d0c890dae08d44412da73b418d77167564bb704ceb12570

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 ## [Unreleased]
 
+## [0.2.0] - 2026-10-11
+
+- `prop` and `state` declarations in an `each` loop over a list of symbols (a literal array, or a constant
+  assigned one in the same file) define a reader and writer per symbol. `Talon::StateSprite` declares its sprite
+  attributes this way, so `x`, `y`, `path`, `angle`, ... now complete on `Talon::GameObject`.
+- Test fixtures synced to Talon c4b670c.
+
 ## [0.1.0] - 2026-10-11
 
 - Initial release: a Solargraph plugin for the [Talon](https://github.com/asimmons91/talon) game framework.
@@ -13,5 +20,6 @@
   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
+[Unreleased]: https://github.com/asimmons91/solargraph-dr_talon/compare/v0.2.0...HEAD
+[0.2.0]: https://github.com/asimmons91/solargraph-dr_talon/compare/v0.1.0...v0.2.0
 [0.1.0]: https://github.com/asimmons91/solargraph-dr_talon/releases/tag/v0.1.0

data/README.md

@@ -86,6 +86,16 @@ Restart your editor's language server. See solargraph-dragonruby's README for ed
     (`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.
+  - Declarations in a loop over a list of symbols define one reader and writer per symbol. The list can be a
+    literal array or a constant assigned one earlier in the same file:
+
+    ```ruby
+    AXES = %i[dx dy].freeze
+    AXES.each { |axis| state axis, default: 0 }   # dx, dx=, dy, dy=
+    ```
+
+    This is how `Talon::StateSprite` declares the sprite attributes of every `Talon::GameObject` (`x`, `y`, `w`,
+    `h`, `path`, `angle`, ...), so they complete on game objects (from Talon c4b670c).
 - **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`.
@@ -105,6 +115,9 @@ Restart your editor's language server. See solargraph-dragonruby's README for ed
   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.
+- Only `each` loops are unrolled, with a single block parameter passed straight to `prop` or `state`. A list
+  that comes from a method call, another file, or contains anything but symbols isn't known statically, so its
+  attributes don't complete.
 - 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

data/lib/solargraph/dr_talon/attribute_node.rb

@@ -10,6 +10,15 @@ module Solargraph
     # A `@return` tag in the comment above the call sets the type; otherwise
     # it's inferred from a literal `default:`.
     #
+    # It also unrolls declarations made in a loop over a list of symbols, as
+    # Talon::StateSprite does for its sprite attributes:
+    #
+    #   ATTRIBUTES = [:x, :y, :w, :h].freeze
+    #   ATTRIBUTES.each { |name| state name }
+    #
+    # The list must be a literal array of symbols, or a constant assigned one
+    # earlier in the same file.
+    #
     # 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.
@@ -44,13 +53,30 @@ module Solargraph
       # @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
+        return true unless receiver.nil? && DSLS.key?(dsl)
+
+        if attribute&.type == :sym
+          host = Host.namespace(region)
+          push_accessors(host, attribute.children[0].to_s, dsl, options, region.code_for(node)) if host
+        elsif (names = iterated_names(attribute))
+          # The loop's block is the closure; the host is around it.
+          host = Host.namespace(region.update(closure: region.closure.closure))
+          names.each { |name| push_accessors(host, name.to_s, dsl, options, "#{dsl} :#{name}") } if host
+        end
+        true
+      end
 
-        host = Host.namespace(region)
-        return true unless host
+      private
 
-        name = attribute.children[0].to_s
-        comments = attribute_comments(dsl, options)
+      # @param host [Solargraph::Pin::Namespace]
+      # @param name [String]
+      # @param dsl [Symbol]
+      # @param options [Array<Parser::AST::Node>]
+      # @param declaration [String] the declaration's code, for undocumented
+      #   attributes
+      # @return [void]
+      def push_accessors(host, name, dsl, options, declaration)
+        comments = attribute_comments(dsl, options, declaration)
         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)
@@ -58,10 +84,53 @@ module Solargraph
           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
+      # The names a declaration like `state name` declares when it's directly
+      # inside `LIST.each { |name| ... }`.
+      #
+      # @param attribute [Parser::AST::Node, nil]
+      # @return [Array<Symbol>, nil]
+      def iterated_names(attribute)
+        return unless attribute&.type == :lvar
+
+        block = region.closure
+        return unless block.is_a?(Solargraph::Pin::Block) && block.node
+
+        call, args = block.node.children
+        return unless call.type == :send && call.children[1] == :each && call.children.length == 2
+
+        params = args.children
+        return unless params.length == 1 && params[0].type == :arg && params[0].children[0] == attribute.children[0]
+
+        symbol_list(call.children[0])
+      end
+
+      # @param list [Parser::AST::Node, nil] a literal array of symbols, or a
+      #   constant assigned one earlier in this file, optionally frozen
+      # @return [Array<Symbol>, nil]
+      def symbol_list(list)
+        list = unfreeze(list)
+        list = unfreeze(constant_value(list)) if list&.type == :const
+        return unless list&.type == :array && list.children.all? { |item| item.type == :sym }
+
+        list.children.map { |item| item.children[0] }
+      end
+
+      # @param node [Parser::AST::Node, nil]
+      # @return [Parser::AST::Node, nil] the receiver of `.freeze`, or `node`
+      def unfreeze(node)
+        frozen = node&.type == :send && node.children[1] == :freeze && node.children.length == 2
+        frozen ? node.children[0] : node
+      end
+
+      # @param const [Parser::AST::Node]
+      # @return [Parser::AST::Node, nil] the value most recently assigned to
+      #   a constant of that name in this file
+      def constant_value(const)
+        name = const.children[1].to_s
+        pins.reverse_each.find { |pin| pin.is_a?(Solargraph::Pin::Constant) && pin.name == name }&.assignment
+      end
 
       # @param host [Solargraph::Pin::Namespace]
       # @param name [String]
@@ -87,10 +156,11 @@ module Solargraph
       #
       # @param dsl [Symbol]
       # @param options [Array<Parser::AST::Node>]
+      # @param declaration [String]
       # @return [String]
-      def attribute_comments(dsl, options)
+      def attribute_comments(dsl, options, declaration)
         comments = comments_for(node).to_s
-        comments = "#{DSLS[dsl]}: `#{region.code_for(node)}`" if comments.strip.empty?
+        comments = "#{DSLS[dsl]}: `#{declaration}`" if comments.strip.empty?
         return comments if comments.match?(/^\s*@return\b/)
 
         type = inferred_type(options)

data/lib/solargraph/dr_talon/version.rb

@@ -2,6 +2,6 @@
 
 module Solargraph
   module DrTalon
-    VERSION = "0.1.0"
+    VERSION = "0.2.0"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: solargraph-dr_talon
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Austin Simmons