solargraph-dragonruby 0.2.0

data/stubs/upstream/inputs.rb

@@ -0,0 +1,286 @@
+module GTK
+  class Inputs
+    # This function returns the last active input which will be set to either :keyboard, :mouse, or :controller.
+    #
+    # The function is helpful when you need to present on screen instructions based on the input the player chose to play with.
+    #
+    # ```ruby
+    # if args.inputs.last_active == :controller
+    #   args.outputs.labels << { x: 60, y: 60, text: "Use the D-Pad to move around." }
+    # else
+    #   args.outputs.labels << { x: 60, y: 60, text: "Use the arrow keys to move around." }
+    # end
+    # ```
+    #
+    # @return [Symbol] returns the last active controller. Will return one of :keyboard, :mouse, or :controller
+    attr_reader :last_active
+
+    # @return [Integer] Returns Kernel.tick_count of which the specific input was last active.
+    attr_reader :last_active_at
+
+    # @return [Integer] Returns the Kernel.global_tick_count of which the specific input was last active.
+    attr_reader :last_active_global_at
+
+    # Refer to the following link for locale strings: [https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes](https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes)
+    #
+    # Defaults to 'en' if locale can’t be retrieved (args.inputs.locale_raw will be nil in this case).
+    #
+    # @return [String] Returns the ISO 639-1 two-letter langauge code based on OS preferences.
+    # @see https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes Wikipedia list of ISO 639-1 codes
+    attr_reader :locale
+
+    # @return [Integer, nil] Returns the tickstamp of the keypress if: the up arrow or w key is pressed or held on the keyboard; or if up is pressed or held on controller_one; or if the left_analog on controller_one is tilted upwards.
+    def up; end
+
+    # @return [Integer, nil] Returns the tickstamp of the keypress if: the down arrow or s key is pressed or held on the keyboard; or if down is pressed or held on controller_one; or if the left_analog on controller_one is tilted downwards.
+    def down; end
+
+    # @return [Integer, nil] Returns the tickstamp of the keypress if: the left arrow or a key is pressed or held on the keyboard; or if left is pressed or held on controller_one; or if the left_analog on controller_one is tilted to the left.
+    def left; end
+
+    # @return [Integer, nil] Returns the tickstamp of the keypress if: the right arrow or d key is pressed or held on the keyboard; or if right is pressed or held on controller_one; or if the left_analog on controller_one is tilted to the right.
+    def right; end
+
+    # This method is aliased to +args.inputs.left_right_with_wasd+.
+    #
+    # The following inputs are inspected to determine the result:
+    #
+    # * Keyboard's left, right arrow keys: args.inputs.keyboard.(left\|right)_arrow
+    # * Keyboard's a, d keys (WASD): args.inputs.keyboard.(a\|d)
+    # * Controller One's DPAD (if a controller is connected): args.inputs.controller_one.dpad_left, args.inputs.controller_one.dpad_right
+    # * Controller One's Left Analog (if a controller is connected): args.inputs.controller_one.left_analog_x_perc.abs >= 0.6
+    #
+    # @return [Integer] Returns -1 (left), 0 (neutral), or +1 (right).
+    def left_right; end
+
+    # This method is aliased to args.inputs.left_right_perc_with_wasd
+    #
+    # The following inputs are inspected to dermine the result:
+    #
+    # * Controller One’s Left Analog (if a controller is connected and the value is not 0.0): args.inputs.controller_one.left_analog_x_perc
+    # * If the left analog isn’t being used, then Controller One’s DPAD is consulted: args.inputs.controller_one.dpad_left, args.inputs.controller_one.dpad_right
+    # * Keyboard’s a, d keys (WASD): args.inputs.keyboard.(a\d)
+    # * Keyboard’s left/right arrow keys: args.inputs.keyboard.(left\|right)_arrow
+    #
+    # @return [Float] Returns a floating point value between -1 and 1
+    def left_right_perc; end
+
+    # This method is aliased to args.inputs.left_right_arrow.
+    #
+    # The following inputs are inspected to determine the result:
+    #
+    # * Keyboard’s left/right arrow keys: args.inputs.keyboard.(left\|right)_arrow
+    # * Controller One’s DPAD (if a controller is connected): args.inputs.controller_one.dpad_left, args.inputs.controller_one.dpad_right
+    # 
+    # WASD and Controller One’s Left Analog Stick are NOT consulted.
+    #
+    # @ return [Integer] Returns -1 (left), 0 (neutral), or +1 (right).
+    def left_right_directional; end
+
+    # The following inputs are inspected to dermine the result:
+    #
+    # * Controller One’s Left Analog (if a controller is connected and the value is not 0.0): args.inputs.controller_one.left_analog_x_perc
+    # * If the left analog isn’t being used, then Controller One’s DPAD is consulted: args.inputs.controller_one.dpad_left, args.inputs.controller_one.dpad_right
+    # * Keyboard’s left/right arrow keys: args.inputs.keyboard.(left\|right)_arrow
+    #
+    # WASD is NOT consulted.
+    #
+    # @ return [Float] Returns a floating point value between -1 and 1.
+    def left_right_directional_perc; end
+
+    # This method is aliased to args.inputs.up_down_with_wasd.
+    #
+    # The following inputs are inspected to determine the result:
+    #
+    # * Keyboard’s up/down arrow keys: args.inputs.keyboard.(up\|down)_arrow
+    # * Keyboard’s w, s keys (WASD): args.inputs.keyboard.(w\|s)
+    # * Controller One’s DPAD (if a controller is connected): args.inputs.controller_one.dpad_up, args.inputs.controller_one.dpad_down
+    # * Controller One’s Up Analog (if a controller is connected): args.inputs.controller_one.up_analog_y_perc.abs >= 0.6
+    #
+    # @return [Integer] Returns -1 (down), 0 (neutral), or +1 (up).
+    def up_down; end
+
+    # This method is aliased to args.inputs.up_down_arrow.
+    #
+    # The following inputs are inspected to determine the result:
+    #
+    # * Keyboard’s up/down arrow keys: args.inputs.keyboard.(up\|down)_arrow
+    # * Controller One’s DPAD (if a controller is connected): args.inputs.controller_one.dpad_up, args.inputs.controller_one.dpad_down
+    #
+    # WASD and Controller One’s Left Analog Stick are NOT consulted.
+    #
+    # @return [Integer] Returns -1 (down), 0 (neutral), or +1 (up).
+    def up_down_directional; end
+
+    # The following inputs are inspected to dermine the result:
+    #
+    # * Controller One’s Left Analog (if a controller is connected and the value is not 0.0): args.inputs.controller_one.up_analog_y_perc
+    # * If the left analog isn’t being used, then Controller One’s DPAD is consulted: args.inputs.controller_one.dpad_up, args.inputs.controller_one.dpad_down
+    # * Keyboard’s up/down arrow keys: args.inputs.keyboard.(up\|down)_arrow
+    #
+    # @return [Float] Returns a floating point value between -1 and 1.
+    def up_down_perc; end
+
+    # @return [String] Returns a string that represents the last key that was pressed on the keyboard.
+    def text; end
+
+    # @return [GTK::Mouse]
+    attr_reader :mouse
+
+    # @return [Hash] Returns a Hash representing all touch points on a touch device.
+    attr_reader :touch
+
+    # @return [Hash] Returns a Hash with x and y denoting a touch point that is on the left side of the screen.
+    attr_reader :finger_left
+
+    # @return [Hash] Returns a Hash with x and y denoting a touch point that is on the right side of the screen.
+    attr_reader :finger_right
+
+    # @return [GTK::Controller] controller one
+    attr_reader :controller_one
+
+    # @return [GTK::Controller] controller two
+    attr_reader :controller_two
+
+    # @return [GTK::Controller] controller three
+    attr_reader :controller_three
+
+    # @return [GTK::Controller] controller four
+    attr_reader :controller_four
+
+    # @return [Array<GTK::Controller>] array of connected Controllers
+    attr_reader :controllers
+
+    # @return [GTK::Keyboard] keyboard
+    attr_reader :keyboard
+  end
+
+  class MousePoint
+    include Typing::Point
+
+    # @return [Typing::Rect] hash containing the x, y position of the click, and a w, h that are always 0.
+    attr_reader :point
+
+    # @return [Integer] the tick_count this click occurred at.
+    attr_reader :created_at
+
+    # @return [Integer] the global_tick_count this click occurred at.
+    attr_reader :global_created_at
+
+    # @return [Integer] Returns the number of ticks between current time and when this click occurred.
+    def created_at_elapsed; end
+
+    # @return [Integer] always returns 0
+    def w; end
+
+    # @return [Integer] always returns 0
+    def h; end
+
+    # @return [Integer] returns the x coordinate of the click
+    def left; end
+
+    # @return [Integer] returns the x coordinate of the click
+    def right; end
+
+    # @return [Integer] returns the y coordinate of the click
+    def top; end
+
+    # @return [Integer] returns the y coordinate of the click
+    def bottom; end
+
+    # Check if the click is inside a rect
+    #
+    # @param rect [Object] a primitive that responds to x, y, w, h
+    # @return [Boolean] Returns true if the click is inside the specified rect
+    def inside_rect? rect; end
+
+    # Check if the click is inside a circle
+    #
+    # @param center_point [Object] any primitive that responds to x, y
+    # @param radius [Float] radius of circle
+    # @return [Boolean] Returns true if the click is inside of a specified circle.
+    def inside_circle? center_point, radius; end
+  end
+
+  class Mouse
+    # @return [Boolean] Return’s true if the game has mouse focus.
+    attr_reader :has_focus
+
+    # @return [Integer] Returns the current x location of the mouse.
+    attr_reader :x
+
+    # @return [Integer] Returns the current y location of the mouse.
+    attr_reader :y
+
+    # @return [Integer] Returns the x location of the mouse on the previous frame.
+    attr_reader :previous_x
+
+    # @return [Integer] Returns the y location of the mouse on the previous frame.
+    attr_reader :previous_y
+
+    # @return [Integer] Returns the difference between the current x location of the mouse and its previous x location.
+    attr_reader :relative_x
+
+    # @return [Integer] Returns the difference between the current y location of the mouse and its previous y location.
+    attr_reader :relative_y
+
+    # Check if the mouse is inside a rect
+    #
+    # @param rect [Typing::Rect] a primitive that responds to x, y, w, h
+    # @return [Boolean] Returns true if the mouse is inside the specified rect
+    def inside_rect? rect; end
+
+    # Check if the mouse is inside a circle
+    #
+    # @param center_point [Typing::Point] any primitive that responds to x, y
+    # @param radius [Float] radius of circle
+    # @return [Boolean] Returns true if the mouse is inside of a specified circle.
+    def inside_circle? center_point, radius; end
+
+    # @return [Boolean] Returns true if the mouse has moved on the current frame.
+    attr_reader :moved
+
+    # @return [Boolean] Returns true if the left mouse button is down.
+    attr_reader :button_left
+
+    # @return [Boolean] Returns true if the middle mouse button is down.
+    attr_reader :button_middle
+
+    # @return [Boolean] Returns true if the right mouse button is down.
+    attr_reader :button_right
+
+    # @return [Integer] Returns a bitmask for all buttons on the mouse: 1 for a button in the down state, 0 for a button in the up state.
+    attr_reader :button_bits
+
+    # @return [Hash, nil]  Returns nil if no mouse wheel actions occurred. Otherwise returns a Hash with x and y (representing movement on each axis).
+    attr_reader :wheel
+
+    # Returns nil if the button event didn't occur this frame, else returns a MousePoint, which includes x, y properties along with helper functions to determine collision: inside_rect?, inside_circle?. 
+    #
+    # To scope to a specific button use .button_left, .button_middle, .button_right, or .button_bits.
+    #
+    # @return [GTK::MousePoint, nil] Returns nil if the button event didn't occur this frame, else returns a MousePoint, which includes x, y properties along with helper functions to determine collision: inside_rect?, inside_circle?.
+    def click; end
+
+    # Returns nil if the button event didn't occur this frame, else returns a MousePoint, which includes x, y properties along with helper functions to determine collision: inside_rect?, inside_circle?. 
+    #
+    # To scope to a specific button use .button_left, .button_middle, .button_right, or .button_bits.
+    #
+    # @return [GTK::MousePoint, nil] Returns nil if the button event didn't occur this frame, else returns a MousePoint, which includes x, y properties along with helper functions to determine collision: inside_rect?, inside_circle?.
+    def down; end
+
+    # Returns nil if the button event didn't occur this frame, else returns a MousePoint, which includes x, y properties along with helper functions to determine collision: inside_rect?, inside_circle?. 
+    #
+    # To scope to a specific button use .button_left, .button_middle, .button_right, or .button_bits.
+    #
+    # @return [GTK::MousePoint, nil] Returns nil if the button event didn't occur this frame, else returns a MousePoint, which includes x, y properties along with helper functions to determine collision: inside_rect?, inside_circle?.
+    def previous_click; end
+
+    # Returns nil if the button event didn't occur this frame, else returns a MousePoint, which includes x, y properties along with helper functions to determine collision: inside_rect?, inside_circle?. 
+    #
+    # To scope to a specific button use .button_left, .button_middle, .button_right, or .button_bits.
+    #
+    # @return [GTK::MousePoint, nil] Returns nil if the button event didn't occur this frame, else returns a MousePoint, which includes x, y properties along with helper functions to determine collision: inside_rect?, inside_circle?.
+    def up; end
+  end
+end

data/stubs/upstream/kernel.rb

@@ -0,0 +1,7 @@
+class ::Kernel
+  class << self
+    # number of ticks elapsed from boot or `$gtk.reset`
+    # @return [Integer]
+    def tick_count; end
+  end
+end

data/stubs/upstream/keyboard.rb

@@ -0,0 +1,38 @@
+module GTK
+  class Keyboard
+
+    # @return [Integer] Returns Kernel.tick_count if any keys on the keyboard were pressed.
+    attr_reader :active
+
+    # @return [Boolean] Returns true if the game has keyboard focus.
+    attr_reader :has_focus
+
+    # @return [Integer, false] Returns the tickstamp of the keypress if up or w is pressed or held on the keyboard.
+    attr_reader :up
+
+    # @return [Integer, false] Returns the tickstamp of the keypress if down or s is pressed or held on the keyboard.
+    attr_reader :down
+
+    # @return [Integer, false] Returns the tickstamp of the keypress if left or a is pressed or held on the keyboard.
+    attr_reader :left
+
+    # @return [Integer, false] Returns the tickstamp of the keypress if right or d is pressed or held on the keyboard.
+    attr_reader :right
+
+    # @return [Integer] Returns -1 (left), 0 (neutral), or +1 (right) depending on results of #left and #right.
+    attr_reader :left_right
+
+    # @return [Integer] Returns -1 (left), 0 (neutral), or +1 (right) depending on results of #up and #up.
+    attr_reader :up_down
+
+    attr_reader :key_down
+
+    attr_reader :key_held
+
+    attr_reader :key_up
+
+    # @return [Hash] Returns a Hash with all keys on the keyboard in their respective state.
+    #   The Hash contains the following keys: :down, :held, :down_or_held, :up
+    attr_reader :keys
+  end
+end

data/stubs/upstream/layout.rb

@@ -0,0 +1,32 @@
+module GTK
+  # Layout provides apis for placing primitives on a virtual grid that’s within the “safe area” accross all platforms.
+  #
+  # This virtual grid is useful for rendering static controls (buttons, menu items, configuration screens, etc).
+  #
+  # The virtual grid is 12 rows by 24 columns (or 24 columns by 12 rows in portrait mode).
+  class Layout
+    class << self
+      # Given a row:, col:, w:, h:, returns a Hash with properties x, y, w, h, and center (which contains a Hash with x, y).
+      #
+      # The virtual grid is 12 rows by 24 columns (or 24 columns by 12 rows in portrait mode).
+      #
+      # @param row [Integer]
+      # @param col [Integer]
+      # @param width [Integer]
+      # @param height [Integer]
+      # @return [Hash] returns a Hash with properties x, y, w, h, and center (which contains a Hash with x, y).
+      def rect row, col, width, height; end
+
+      # Function returns an array of primities that can be rendered to the screen to help you place items within the grid.
+      #
+      # @return [Array] an array of primities that can be rendered to the screen to help you place items within the grid.
+      def debug_primitives; end
+
+      # @return [Boolean] Returns true if orientation is :portrait.
+      def portrait?; end
+
+      # @return [Boolean] Returns true if orientation is :landscape.
+      def landscape?; end
+    end
+  end
+end

data/stubs/upstream/numeric.rb

@@ -0,0 +1,82 @@
+class Numeric
+  # converts `self` from seconds to ticks
+  # @return [Float]
+  def seconds
+  end
+
+  # returns `self` clamped to the `[0; 255]` range and converted to an integer
+  # @return [Integer]
+  def to_byte
+  end
+
+  # wrapping clamp
+  # examples:
+  # ```rb
+  # 5.clamp_wrap(2, 4)     # =>  2
+  # 5.clamp_wrap(10, 20)   # => 16
+  # 123.clamp_wrap(10, 20) # => 13
+  # ```
+  # @param min [Numeric]
+  # @param max [Numeric]
+  # @return [Numeric]
+  def clamp_wrap(min, max)
+  end
+
+  # linear interpolation from `self` to `to` at `step`
+  # @param to [Numeric] number to lerp to
+  # @param step [Numeric] time; often denoted `t`
+  # @return [Numeric]
+  def lerp(to, step)
+  end
+
+  # map `self` from one range to another
+  # @param r1_begin [Numeric] the beginning of the source range
+  # @param r1_end [Numeric] the end of the source range
+  # @param r2_begin [Numeric] the beginning of the result range
+  # @param r2_end [Numeric] the end of the result range
+  # @return [Numeric]
+  def remap(r1_begin, r1_end, r2_begin, r2_end)
+  end
+
+  # calls the block with successive integers up to `self.to_i` (exclusive)
+  # shorthand for `self.times.each`
+  # @yieldparam i [Integer] successive integers
+  # @return [self]
+  def each(&blk)
+  end
+
+  # calls the block with a pair of integers
+  # shorthand for `self.times.each_with_index`
+  # @yieldparam i [Integer]
+  # @yieldparam idx [Integer]
+  # @return [self]
+  def each_with_index(&blk)
+  end
+
+  # calls the block with successive integers up to `self.to_i` (exclusive)
+  # and constructs an array of the yielded values
+  # shorthand for `self.times.map`
+  # @yieldparam i [Integer] successive integers
+  # @return [Array]
+  def map(&blk)
+  end
+
+  # calls the block with a pair of integers
+  # and constructs an array of the yielded values
+  # shorthand for `self.times.map_with_index`
+  # @yieldparam i [Integer]
+  # @yieldparam idx [Integer]
+  # @return [Array]
+  def map_with_index(&blk)
+  end
+
+  # calls the block with a pair of integers
+  # and constructs an array resulting from the concatenation
+  # of the yielded arrays
+  # shorthand for `self.times.flat_map`
+  # @yieldparam i [Integer]
+  # @yieldreturn [Array]
+  # @return [Array]
+  def flat_map(&blk)
+  end
+end

data/stubs/upstream/outputs.rb

@@ -0,0 +1,55 @@
+module GTK
+  class Outputs
+    # @return [String, nil] name of the render target or `nil` if top-level 
+    attr_accessor :target
+
+    # @return [Integer] width of the outputs instance
+    attr_accessor :width
+
+    # @return [Integer] height of the outputs instance
+    attr_accessor :height
+
+    # @return [Boolean] returns whether the target is transient
+    attr_accessor :transient
+
+    # @return [Hash, Array] either a color hash (color keys default to `230` if not passed, alpha defaults to `255`),
+    #                       or a color array of the format `[r, g, b]` or `[r, g, b, a]`
+    attr_accessor :background_color
+
+    # Whether to clear the render target this frame, before any other operations are added to it.
+    #
+    # Defaults to True.
+    #
+    # @return [Boolean]
+    attr_accessor :clear_before_render
+
+    # @return [OutputsArray]
+    attr_reader :solids, :sprites, :lines, :labels, :borders, :primitives, :reserved, :debug,
+                :static_solids, :static_sprites, :static_lines, :static_labels, :static_borders,
+                :static_primitives, :static_reserved, :static_debug, :screenshots
+
+    # @param name [String, Symbol]
+    # @return [Outputs] render target named by `name`
+    def render_target(name); end
+
+    # @param name [String, Symbol]
+    # @return [Outputs] render target named by `name`
+    def [](name); end
+
+    # sets `transient` to `true`
+    def transient!; end
+
+    # pushes `obj` into the `primitives` array
+    # @param obj [Object]
+    # @return [self]
+    def <<(obj); end
+
+    alias w width
+    alias w= width=
+    alias h height
+    alias h= height=
+
+    # @return [Boolean] returns whether a screenshot can be taken on the current tick
+    def can_screenshot?; end
+  end
+end

data/stubs/upstream/outputs_array.rb

@@ -0,0 +1,4 @@
+module GTK
+  class OutputsArray < Array
+  end
+end

data/stubs/upstream/phantom_types.rb

@@ -0,0 +1,25 @@
+# parent module holding all phantom types used only for typing arguments/return values
+# none of these classes/modules actually exist in the dragonruby runtime
+module Typing
+  # phantom type denoting a point-like object
+  module Point
+    # @return [Integer, Float]
+    attr_reader :x, :y
+  end
+
+  # phantom type denoting a rect-like object
+  module Rect
+    # @return [Integer, Float]
+    attr_reader :x, :y, :w, :h
+  end
+
+  # phantom type for the hash returned by a `GTK::Runtime#get_pixels` call
+  # not a subclass of `Hash` because you probably(tm) will not use it as a normal hash
+  module PixelsHash
+    # @return [Integer]
+    attr_reader :w, :h
+
+    # @return [Array<Integer>]
+    attr_reader :pixels
+  end
+end

data/stubs/upstream/toplevel.rb

@@ -0,0 +1,13 @@
+# @!method tick(args)
+#   @abstract tick function, override it with your game
+#   @param args [GTK::Args]
+#   @return [void]
+
+# @!method boot(args)
+#   @abstract boot function, override for setup that has to happen once, at the very beginning of the dr process
+#   @param args [GTK::Args]
+#   @return [void]
+
+# @!method reset(args)
+#   @param args [GTK::Args]
+#   @return [void]

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification
+name: solargraph-dragonruby
+version: !ruby/object:Gem::Version
+  version: 0.2.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: Adds YARD-documented DragonRuby GTK API pins (args, outputs, inputs,
+  $gtk, Geometry, ...) to Solargraph so LSP editors get autocomplete, hover and go-to-definition
+  in DragonRuby games.
+email:
+- austin_simmons@fastmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- NOTICE
+- README.md
+- Rakefile
+- lib/solargraph-dragonruby.rb
+- lib/solargraph/dragonruby.rb
+- lib/solargraph/dragonruby/convention.rb
+- lib/solargraph/dragonruby/macro_node.rb
+- lib/solargraph/dragonruby/version.rb
+- sig/solargraph/dragonruby.rbs
+- stubs/extensions/README.md
+- stubs/extensions/args.rb
+- stubs/extensions/array.rb
+- stubs/extensions/attr.rb
+- stubs/extensions/easing.rb
+- stubs/extensions/entity.rb
+- stubs/extensions/geometry.rb
+- stubs/extensions/grid.rb
+- stubs/extensions/inputs.rb
+- stubs/extensions/layout.rb
+- stubs/extensions/log.rb
+- stubs/extensions/main.rb
+- stubs/extensions/numeric.rb
+- stubs/extensions/outputs.rb
+- stubs/extensions/runtime.rb
+- stubs/extensions/string.rb
+- stubs/extensions/typing.rb
+- stubs/extensions/zlib.rb
+- stubs/upstream/LICENSE.txt
+- stubs/upstream/UPSTREAM
+- stubs/upstream/args.rb
+- stubs/upstream/constants.rb
+- stubs/upstream/controller.rb
+- stubs/upstream/easing.rb
+- stubs/upstream/geometry.rb
+- stubs/upstream/globals.rb
+- stubs/upstream/gtk.rb
+- stubs/upstream/inputs.rb
+- stubs/upstream/kernel.rb
+- stubs/upstream/keyboard.rb
+- stubs/upstream/layout.rb
+- stubs/upstream/numeric.rb
+- stubs/upstream/outputs.rb
+- stubs/upstream/outputs_array.rb
+- stubs/upstream/phantom_types.rb
+- stubs/upstream/toplevel.rb
+homepage: https://github.com/asimmons91/solargraph-dragonruby
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/asimmons91/solargraph-dragonruby
+  changelog_uri: https://github.com/asimmons91/solargraph-dragonruby/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 DragonRuby Game Toolkit API completion
+test_files: []