rsx-rb 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c8c99446f5f4a181f5076fc1c953abe88019abe2d88648f3b2838065103b9d01
-  data.tar.gz: 756fc7f9d2b864fd4f8bc3bed5f7f841fa9f07fc0659ebaaa432da0caaa6c960
+  metadata.gz: '09ece5a47645dffe35d921bbf2515c6dd929b3946975c26f2c054ebf44eba867'
+  data.tar.gz: 557cb7747622220af0b415dc321d47d5bf38701e41673d48d095efc900940ce2
 SHA512:
-  metadata.gz: 21380274662f0aa00351a671c6742f4854d908e7e614bd61191111c038a08e0e5b00f545cebd442b502a6432bc350f1f2efde566dca012d0a0ceea142187ef00
-  data.tar.gz: 19452fed00b1aaefcbeaf532216b0da8e032ae7cd07cd7b6a5a228f5fa4bdea966f0d1edd417eb98ed8ef32e9c14abadb9fd4fdb662cca8a52d85d552af5a510
+  metadata.gz: a3206858816384a46c2383d6361b0a29614815f7a556d6b95ba3682dd1eea75d4bf1de5edc45b3b54cb3967542d553c4947fb20676a6139a5f93a6c905aa160e
+  data.tar.gz: 9e1d5bcde977a58d87be474c8dbe9e1704ed38849e5c6e763fb8dd086c76ecc388b3db2215b296f63fabf9c0d94c171f782a767ef5e3e91ec4fa2fa1e65be26c

data/CHANGELOG.md

@@ -5,11 +5,56 @@ All notable changes to RSX are documented here. This project follows
 
 ## [Unreleased]
 
-- Publish the gem as `rsx-rb` on RubyGems. The require path remains `rsx`.
+## [0.2.0] - 2026-09-16
+
+### Fixed
+
+- **Attribute name injection.** Hash keys for `data={...}` and `aria={...}` were written into the
+  tag without validation, so a key carrying a quote could close the attribute and inject another
+  one. Keys that are not usable attribute names now raise `ArgumentError`, in spreads too.
+- `<script>` and `<style>` are parsed as raw text, as HTML defines them. CSS selectors with `>`,
+  JavaScript comparisons and object literals, and `"</div>"` inside a string no longer break
+  compilation. Dynamic content goes through `dangerouslySetInnerHTML`.
+- Whitespace inside `<pre>` and `<textarea>` is preserved rather than joined the way JSX joins it,
+  which had been changing what the browser displayed.
+- A void element given children or a closing tag (`<br></br>`) reports the tag and line instead of
+  raising a Ruby syntax error from the generated file.
+- Duplicate attributes collapse at compile time keeping the last value, as React does, instead of
+  being emitted twice — which was invalid HTML and picked the first value.
+- `Proc`, `Method`, `Hash` and `Array` attribute values raise instead of being inspected into the
+  document, so `onClick={-> { }}` no longer renders `onclick="#<Proc…>"`.
+- Markup in argument position (`wrap <div>x</div>`) reports that it needs parentheses instead of
+  compiling to a chain of comparisons that fails elsewhere.
+- `list <<x` is an append again; the second `<` was being read as the start of a tag.
+- Static markup slots no longer accumulate for the life of the process: the loader drops a file's
+  slots when it reloads it. Filling a slot is synchronized, so it is no longer a bare `||=` on a
+  Hash shared between threads.
+- Template resolution is confined to `.rsx` files inside the configured paths or the working
+  directory. It previously accepted absolute paths and `../`, so `render_file` on a value from a
+  request could name any file on disk — and loading a template evaluates it.
+- `RSX.render_component` copies the props hash instead of writing `:children` into the one it was
+  given.
+
+### Added
+
+- `.rsx` templates take part in Rails' template digests, so a `cache` block wrapping an `.rsx`
+  partial is invalidated when that partial, or anything it renders, changes.
+- `rails generate rsx:component Card title body`.
+- CI across supported Rubies and ActionView versions, including a run without Rails, and a job
+  that installs the built gem and renders with it. The Rails suite previously skipped in full
+  whenever ActionView was absent, which was always.
+- RuboCop, configured to the style the code already uses.
+
+### Changed
+
+- `COMPILER_VERSION` is `2`: generated Ruby changed, so cached output from 0.1.0 is recompiled
+  automatically on first use.
+- `RSX::CompileCache#fetch` is now `fetch_or_compile`, since both arguments identify the entry and
+  the old name read like `Hash#fetch`. Internal.
 
 ## [0.1.0]
 
-First release.
+First release, published as `rsx-rb` on RubyGems. The require path is `rsx`.
 
 - `.rsx` templates: JSX syntax with Ruby in place of JavaScript — `<>` fragments, `{}`
   expression containers, `{/* comments */}`, JSX whitespace rules, void and self-closing

data/README.md

@@ -19,6 +19,20 @@ export default Greeting
 
 [Example: RSX with Tailwind CSS](https://github.com/derwydd/rsx-working-example)
 
+Install it from RubyGems as **`rsx-rb`** (`rsx` is already taken):
+
+```ruby
+# Gemfile
+gem "rsx-rb"
+```
+
+```bash
+bundle install
+# or: gem install rsx-rb
+```
+
+Then `require "rsx"`. Bundler does that for you.
+
 Templates are compiled ahead of time into plain Ruby string building, so rendering is
 concatenation and escaping — no interpreter, no virtual DOM, no diffing. RSX has **zero runtime
 dependencies**; the Rails integration activates itself only when Rails is already loaded.
@@ -306,6 +320,15 @@ rows   = items.map { |i| <li>{i}</li> }   # block body
 return <p>{n < 10 ? "few" : "many"}</p>   # comparison inside a container
 ```
 
+A method call is a value, so markup as a bare argument needs parentheses — `wrap <div>x</div>`
+would be a chain of comparisons to Ruby. RSX reports that where you wrote it instead of letting
+it compile:
+
+```ruby
+wrap(<div>x</div>)   # ✓
+wrap <div>x</div>    # ✗ "markup here needs parentheses"
+```
+
 ### Fragments
 
 Multiple sibling elements need one parent. Use `<>...</>` when you do not want a wrapper
@@ -406,6 +429,28 @@ joined with a single space. So this…
 
 …renders `<p>Hello, world</p>`. Use `{" "}` when you need a space JSX would have collapsed.
 
+Inside `<pre>` and `<textarea>` whitespace is significant, so RSX leaves it exactly as written
+rather than joining lines. This is one of the few places RSX deliberately parts ways with JSX,
+which would collapse it and change what the browser displays.
+
+### `<script>` and `<style>`
+
+HTML treats these two as *raw text*: no child elements, no character references. RSX does the
+same, so their contents are passed through byte for byte and nothing inside is markup:
+
+```ruby
+<style>.card > .title { color: red }</style>
+<script>if (a < b) { render({ x: 1 }); }</script>
+```
+
+Selectors with `>`, JavaScript comparisons, object literals and `"</div>"` inside a string all
+work as written. Since the body is not parsed, `{}` is not an expression container either — to
+put dynamic content in a script, use `dangerouslySetInnerHTML`:
+
+```ruby
+<script dangerouslySetInnerHTML={{ __html: "window.config = #{RSX.json(config)}" }} />
+```
+
 ### Escaping and raw HTML
 
 Interpolated values are HTML-escaped. Strings already marked safe (RSX's own output, and
@@ -477,6 +522,11 @@ Following React, booleans become the strings `"true"`/`"false"`, and `nil` drops
 # => <div data-user-id="7" data-ids="[1,2]" aria-label="Close" aria-hidden="true"></div>
 ```
 
+Values are escaped, but a *name* is written into the tag as-is, so it cannot be. A key that is
+not a usable attribute name — one carrying a space, a quote or an angle bracket — raises
+`ArgumentError` rather than being emitted, since otherwise a key built from untrusted input
+could close the attribute and start another one. The same applies to spread keys.
+
 ### Spread
 
 Both the JSX and the Ruby spelling are accepted:
@@ -491,6 +541,10 @@ the same HTML attribute collapse, keeping the last value. So `className="link"`
 a `class` or `className` coming from `attrs`, rather than emitting the attribute twice. A `nil`
 or `false` spread contributes nothing.
 
+Two attributes naming the same HTML attribute collapse the same way without a spread, at compile
+time: `<div className="a" className="b" />` renders `class="b"`. Emitting both would be invalid
+HTML *and* pick the opposite winner, since browsers keep the first.
+
 Spread works on components too, where it becomes keyword arguments.
 
 ### Event handlers
@@ -505,6 +559,10 @@ There is no client-side runtime, so handlers are strings — the value of an HTM
 For real interactivity, use the attributes your JS framework expects
 (`data-controller`, `data-action`, `hx-post`, …) — they pass through untouched.
 
+Passing a lambda raises, rather than writing `#<Proc…>` into the document. So do a `Hash` or
+`Array` given to an attribute that does not take one — only `class` accepts an Array, and only
+`class`, `style`, `data` and `aria` accept a Hash.
+
 ### Void and self-closing elements
 
 Void elements never get a closing tag, whether or not you write `/`:
@@ -515,6 +573,9 @@ Void elements never get a closing tag, whether or not you write `/`:
 <circle r={4} />  # SVG keeps XML self-closing syntax => <circle r="4"/>
 ```
 
+They also take no children and have no closing tag, so `<br></br>` and `<img src={u}>alt</img>`
+are reported as errors where they are written.
+
 ---
 
 ## Components
@@ -820,6 +881,25 @@ Any view, partial or layout can be `.html.rsx`. Inside one, `self` is the view c
 Partial locals are local variables, exactly as in ERB. Output is html-safe, so `.rsx` and ERB
 templates can render each other freely.
 
+Rails' strict locals comment works too, since it is an ordinary Ruby comment in `.rsx`:
+
+```ruby
+# locals: (author:, byline_class: "byline")
+<p className={byline_class}>{author.name}</p>
+```
+
+`.rsx` templates also take part in Rails' template digests, so a `cache` block wrapping an `.rsx`
+partial is invalidated when that partial — or any partial it renders — changes.
+
+### Generating a component
+
+```bash
+bin/rails generate rsx:component Card title body
+```
+
+Writes `app/components/card.rsx` (or into the first entry of `config.rsx.paths`) with `title:` and
+`body:` as keyword props.
+
 ### Components from ERB, Haml or Slim
 
 ```erb
@@ -914,7 +994,7 @@ where compiled output goes, `-p/--prop NAME=VALUE` passes a string prop.
 
 | Setting | Default | Meaning |
 | --- | --- | --- |
-| `paths` | `app/components`, `app/rsx` (Rails) | Directories searched for `.rsx` files and imports |
+| `paths` | `app/components`, `app/rsx` (Rails) | Directories searched for `.rsx` files and imports; also the limit of what can be resolved |
 | `cache_dir` | `tmp/cache/rsx` | Where compiled Ruby is stored; `nil` compiles in memory |
 | `cache_store` | `RSX::Cache::Memory` | Store for component and fragment caches |
 | `component_namespace` | `Object` | Module that `component Name` constants are defined under |
@@ -924,6 +1004,11 @@ Useful entry points on the `RSX` module: `compile`, `load`, `load_all`, `reload!
 `precompile!`, `render`, `render_file`, `render_source`, `template`, `lookup_component`,
 `create_context`, `cache`, `config`, `configure`, `reset!`.
 
+Loading a template evaluates it, so resolution only ever matches `.rsx` files inside `paths` or
+the working directory — `../` cannot climb out of them, and an absolute path elsewhere is refused.
+A path from a request therefore cannot reach anything else on disk, though it is still better to
+map user input to a known set of templates than to pass it to `render_file` directly.
+
 ---
 
 ## Differences from React
@@ -940,9 +1025,16 @@ runtime differences are worth stating plainly:
   `&&`/`||` semantics differ around `0` and `""`, and `nil` replaces `null`/`undefined`.
 - **Expression containers only exist inside markup.** At the top level of a template file, `{}`
   is a Ruby hash.
-- **Whitespace, escaping, fragments, spread, `dangerouslySetInnerHTML`, `className`/`style`
-  handling, boolean and `data`/`aria` attributes, children, render props, context, and
-  `import`/`export default`** all behave as they do in React.
+- **`<pre>` and `<textarea>` keep their whitespace** instead of having it collapsed. JSX collapses
+  it, which for server-rendered HTML just changes what the browser shows.
+- **`<script>` and `<style>` are raw text**, as HTML defines them, so `{}` is not an expression
+  container inside them. Use `dangerouslySetInnerHTML` for dynamic script or style content.
+- **Mistakes are errors, not output.** A void element with children, a lambda in an attribute,
+  and an attribute name that would break out of its quotes all raise instead of rendering
+  something surprising.
+- **Escaping, fragments, spread, `dangerouslySetInnerHTML`, `className`/`style` handling, boolean
+  and `data`/`aria` attributes, children, render props, context, and `import`/`export default`**
+  all behave as they do in React.
 
 ---
 

data/lib/generators/rsx/component/component_generator.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "rails/generators/named_base"
+
+module RSX
+  module Generators
+    # rails generate rsx:component Card title body
+    #
+    # Writes the component into the first configured RSX path, so the file lands
+    # somewhere the loader already looks.
+    class ComponentGenerator < ::Rails::Generators::NamedBase
+      # Thor derives a namespace by inserting an underscore before every capital,
+      # which turns RSX into "r_s_x". Declare the real one.
+      namespace "rsx:component"
+
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Creates an RSX component with one keyword prop per given name."
+
+      argument :props, type: :array, default: [], banner: "prop prop"
+
+      def create_component_file
+        template "component.rsx.tt", File.join(component_root, "#{file_path}.rsx")
+      end
+
+      private
+
+      DEFAULT_ROOT = "app/components"
+
+      def component_root
+        configured = Array(::RSX.config.paths).first
+        return DEFAULT_ROOT if configured.nil?
+
+        relative = Pathname.new(configured.to_s).relative_path_from(Pathname.new(destination_root)).to_s
+        relative.start_with?("..") ? DEFAULT_ROOT : relative
+      rescue ArgumentError
+        # The configured path is on another volume, so it cannot be expressed
+        # relative to the application root.
+        DEFAULT_ROOT
+      end
+
+      def parameter_list
+        return "props" if props.empty?
+
+        props.map { |prop| "#{prop}:" }.join(", ")
+      end
+    end
+  end
+end

data/lib/generators/rsx/component/templates/component.rsx.tt

@@ -0,0 +1,15 @@
+component <%= class_name %> do |<%= parameter_list %>|
+  return (
+    <div className="<%= file_name.dasherize %>">
+<% if props.any? -%>
+<% props.each do |prop| -%>
+      <p className="<%= file_name.dasherize %>__<%= prop.dasherize %>">{<%= prop %>}</p>
+<% end -%>
+<% else -%>
+      <p><%= class_name %></p>
+<% end -%>
+    </div>
+  )
+end
+
+export default <%= class_name %>

data/lib/rsx/attributes.rb

@@ -111,6 +111,15 @@ module RSX
       feTurbulence mpath set
     ].to_h { |name| [name, true] }.freeze
 
+    # Elements whose content is raw text rather than markup. HTML gives these no
+    # child elements and no character references, so `<`, `>` and `{` inside them
+    # are ordinary characters: CSS selectors and JavaScript work as written.
+    RAW_TEXT = %w[script style].to_h { |name| [name, true] }.freeze
+
+    # Elements where whitespace is significant, so JSX's line-joining rules
+    # would change what the browser displays.
+    PREFORMATTED = %w[pre textarea listing plaintext].to_h { |name| [name, true] }.freeze
+
     # CSS properties that take a bare number (everything else gets "px").
     UNITLESS_CSS = %w[
       animation-iteration-count aspect-ratio border-image-outset border-image-slice
@@ -126,11 +135,23 @@ module RSX
     # Props that describe the element to RSX rather than to the browser.
     IGNORED = %w[key ref children suppressHydrationWarning].to_h { |name| [name, true] }.freeze
 
-    INVALID_NAME = %r{[\s"'>/=\0]}
+    INVALID_NAME = %r{[\s"'<>/=\0]}
     CAMEL_BOUNDARY = /([a-z0-9])([A-Z])/
 
     module_function
 
+    # Attribute names are written into the tag verbatim, so a name carrying a
+    # quote or a space would end the attribute and start a new one. Values are
+    # escaped, but names cannot be, which is why anything malformed is refused
+    # rather than mangled into something that still parses as HTML.
+    def validate_name!(name)
+      return name unless name.empty? || name.match?(INVALID_NAME)
+
+      raise ArgumentError,
+            "#{name.inspect} is not a usable HTML attribute name. Attribute names are " \
+            "written into the tag as-is, so they cannot come from untrusted input."
+    end
+
     # Maps a prop name to its HTML attribute name, or nil when the prop should
     # not be rendered at all.
     def attribute_name(prop)
@@ -158,15 +179,41 @@ module RSX
       SELF_CLOSING.key?(tag)
     end
 
+    def raw_text?(tag)
+      RAW_TEXT.key?(tag)
+    end
+
+    def preformatted?(tag)
+      PREFORMATTED.key?(tag)
+    end
+
     # Renders one attribute, including its leading space: ` href="/x"`.
     def render(name, value)
       case value
       when nil, false then ""
       when true then boolean?(name) ? " #{name}" : %( #{name}="true")
+      when Proc, Method, Hash, Array then raise ArgumentError, unrenderable(name, value)
       else %( #{name}="#{Escape.attribute(value)}")
       end
     end
 
+    # An attribute can only ever be a string, so these types are always a mistake
+    # rather than a value to inspect into the document.
+    def unrenderable(name, value)
+      advice =
+        case value
+        when Proc, Method
+          "Event handlers are HTML attributes, not callbacks: pass the JavaScript " \
+          "to run as a string, as in onClick=\"submit()\"."
+        when Hash
+          "Only class, style, data and aria accept a Hash."
+        when Array
+          "Only class accepts an Array."
+        end
+
+      "cannot render #{value.class} as the #{name} attribute. #{advice}"
+    end
+
     # class={...} accepts a String, Symbol, Array or Hash.
     def render_class(value)
       tokens = class_tokens(value)
@@ -179,7 +226,6 @@ module RSX
       case value
       when nil, false, true then []
       when String then value.empty? ? [] : [value]
-      when Symbol then [value.to_s]
       when Array then value.flat_map { |item| class_tokens(item) }
       when Hash then value.filter_map { |token, on| token.to_s if on }
       else [value.to_s]
@@ -235,7 +281,8 @@ module RSX
           # Like React, data-* and aria-* keep booleans as the strings "true"
           # and "false" rather than becoming bare attributes: ARIA values are
           # enumerated, so `aria-hidden` alone means nothing.
-          %( #{prefix}-#{css_property(key)}="#{Escape.attribute(nested_value(raw))}")
+          name = validate_name!("#{prefix}-#{css_property(key)}")
+          %( #{name}="#{Escape.attribute(nested_value(raw))}")
         end.join
       else render(prefix, value)
       end
@@ -302,9 +349,9 @@ module RSX
         when "dangerouslySetInnerHTML" then next
         else
           name = attribute_name(prop)
-          next if name.nil? || name.empty? || name.match?(INVALID_NAME)
+          next if name.nil? || name.empty?
 
-          out << render(name, value)
+          out << render(validate_name!(name), value)
         end
       end
       out

data/lib/rsx/children.rb

@@ -46,9 +46,9 @@ module RSX
     end
 
     # Render props: {children.call(item)} passes a value back to the caller.
-    def call(*arguments, **options, &block)
+    def call(...)
       raw = value
-      return raw.call(*arguments, **options, &block) if raw.respond_to?(:call)
+      return raw.call(...) if raw.respond_to?(:call)
 
       raw
     end

data/lib/rsx/cli.rb

@@ -37,7 +37,10 @@ module RSX
         opts.on("-c", "--cache-dir DIR", "Directory for compiled output") do |dir|
           options[:cache_dir] = dir
         end
-        opts.on("-h", "--help", "Show this message") { puts opts; return 0 }
+        opts.on("-h", "--help", "Show this message") do
+          puts opts
+          return 0
+        end
       end
 
       arguments = parser.parse(argv)
@@ -75,6 +78,9 @@ module RSX
 
     def render(files, props)
       abort_missing(files)
+      # Naming a file on the command line is as explicit as it gets, so add its
+      # directory to the load path rather than have the loader refuse it.
+      RSX.config.paths |= files.map { |file| File.dirname(File.expand_path(file)) }
       files.each { |file| puts RSX.render_file(File.expand_path(file), **props) }
     end
 

data/lib/rsx/codegen.rb

@@ -49,6 +49,8 @@ module RSX
       case node
       when Nodes::Text
         parts << [:static, Escape.static_text(node.value), node.line]
+      when Nodes::RawText
+        parts << [:static, node.value, node.line]
       when Nodes::Expression
         # The extra parentheses let a container hold anything Ruby accepts as an
         # expression, including modifiers: {greeting if signed_in?}.
@@ -83,7 +85,7 @@ module RSX
       if attributes.any? { |attribute| attribute.kind == :spread }
         emit_spread_attributes(attributes, parts)
       else
-        attributes.each { |attribute| emit_attribute(attribute, parts) }
+        dedupe(attributes).each { |attribute| emit_attribute(attribute, parts) }
       end
 
       if inner_html
@@ -99,11 +101,11 @@ module RSX
       end
 
       if node.children.empty?
-        if node.self_closing && Attributes.self_closing?(tag)
-          parts << [:static, "/>", last_line(parts, node)]
-        else
-          parts << [:static, "></#{tag}>", last_line(parts, node)]
-        end
+        parts << if node.self_closing && Attributes.self_closing?(tag)
+                   [:static, "/>", last_line(parts, node)]
+                 else
+                   [:static, "></#{tag}>", last_line(parts, node)]
+                 end
         return
       end
 
@@ -139,6 +141,20 @@ module RSX
       parts << [:dynamic, source, attributes.first.line]
     end
 
+    # Two props naming the same HTML attribute would otherwise be written twice,
+    # which is invalid HTML and inverts the result: React keeps the last value,
+    # browsers keep the first. Matches Attributes.merge by holding the first
+    # position and taking the last value.
+    def dedupe(attributes)
+      return attributes if attributes.length < 2
+
+      # Reassigning a Hash key keeps its original position and takes the new
+      # value, which is the merge rule verbatim.
+      by_name = {}
+      attributes.each { |attribute| by_name[Attributes.canonical_name(attribute.name)] = attribute }
+      by_name.length == attributes.length ? attributes : by_name.values
+    end
+
     def attribute_pair(attribute)
       key = symbol_literal(attribute.name)
 
@@ -248,10 +264,14 @@ module RSX
       buffer = +""
 
       # Markup with nothing dynamic in it is built once and then reused from a
-      # per-call-site slot, so re-rendering it allocates nothing at all. The
-      # literal after `||=` is never evaluated again after the first render.
-      buffer << "(::RSX::STATICS[#{static_slot}] ||= " if static
-      buffer << (static ? "::RSX.static(" : "::RSX::SafeString.new(")
+      # per-call-site slot, so re-rendering it allocates nothing at all. Once the
+      # slot is filled the read short-circuits and the literal is never built.
+      if static
+        slot = static_slot
+        buffer << "(::RSX::STATICS[#{slot}] || ::RSX.define_static(#{slot}, "
+      else
+        buffer << "::RSX::SafeString.new("
+      end
       state = { line: start_line, open: false }
 
       parts.each do |kind, text, line|

data/lib/rsx/compile_cache.rb

@@ -25,8 +25,10 @@ module RSX
       Digest::SHA256.hexdigest("#{COMPILER_VERSION}\0#{source}")[0, 32]
     end
 
-    # Returns the compiled Ruby for source, compiling only on a cache miss.
-    def fetch(path, source)
+    # Returns the compiled Ruby for source, compiling only on a cache miss. Not
+    # named fetch: both arguments identify the entry, so a reader expecting
+    # Hash#fetch would take source for a default value.
+    def fetch_or_compile(path, source)
       key = digest(source)
       cached = @lock.synchronize { @memory[key] }
       return cached if cached

data/lib/rsx/component.rb

@@ -14,12 +14,7 @@ module RSX
     EMPTY_PROPS = {}.freeze
 
     class << self
-      attr_accessor :rsx_source_path, :rsx_source_digest
-      attr_writer :rsx_cache_options
-
-      def rsx_cache_options
-        @rsx_cache_options
-      end
+      attr_accessor :rsx_source_path, :rsx_source_digest, :rsx_cache_options
 
       # Marks a component whose output never varies. The compiler sets this
       # automatically when a component body is nothing but static markup.
@@ -66,7 +61,7 @@ module RSX
         custom = options[:key]
         payload =
           if custom.nil?
-            (props || EMPTY_PROPS).reject { |key, _| key == :children }
+            (props || EMPTY_PROPS).except(:children)
           elsif custom.respond_to?(:arity) && custom.arity.zero?
             custom.call
           else
@@ -157,9 +152,7 @@ module RSX
 
     # The object that rendered this component: a view context in Rails, the
     # parent component when nested, or nil when rendered directly.
-    def rsx_parent
-      @rsx_parent
-    end
+    attr_reader :rsx_parent
 
     # The nearest non-component render context, i.e. the Rails view. Gives access
     # to url helpers, form builders, `t`, asset helpers and anything else the

data/lib/rsx/loader.rb

@@ -7,7 +7,8 @@ module RSX
   class Loader
     EXTENSIONS = [".rsx", ".html.rsx"].freeze
 
-    Entry = Struct.new(:path, :digest, :mtime, :components, :default, :template, keyword_init: true) do
+    Entry = Struct.new(:path, :digest, :mtime, :components, :default, :template, :statics_prefix,
+                       keyword_init: true) do
       # Markup files render through a template; component files render their
       # default export.
       def renderable
@@ -52,12 +53,13 @@ module RSX
 
         unload(existing) if existing
 
-        entry = Entry.new(path: absolute, digest: digest, mtime: mtime(absolute), components: [], default: nil)
+        entry = Entry.new(path: absolute, digest: digest, mtime: mtime(absolute), components: [],
+                          default: nil, statics_prefix: Transformer.static_prefix(source))
         @entries[absolute] = entry
         @stack.push(entry)
 
         begin
-          ruby = compile_cache.fetch(absolute, source) do
+          ruby = compile_cache.fetch_or_compile(absolute, source) do
             Transformer.transform(source, path: absolute)
           end
 
@@ -96,7 +98,9 @@ module RSX
     # Reloads only the files whose contents changed. Used by the Rails reloader.
     def reload!
       @monitor.synchronize do
-        @entries.values.each do |entry|
+        # values takes a snapshot, which each_value would not: the body reloads
+        # and deletes entries while iterating.
+        @entries.values.each do |entry| # rubocop:disable Style/HashEachMethods
           if !File.file?(entry.path)
             unload(entry)
             @entries.delete(entry.path)
@@ -128,21 +132,18 @@ module RSX
       end
 
       candidates.each do |candidate|
-        return candidate if File.file?(candidate)
-
-        EXTENSIONS.each do |extension|
-          with_extension = "#{candidate}#{extension}"
-          return with_extension if File.file?(with_extension)
-        end
+        found = rsx_file_at(candidate)
+        return found if found && within_roots?(found)
       end
 
       nil
     end
 
     def resolve!(spec, from: nil)
-      resolve(spec, from: from) ||
-        raise(FileNotFoundError, "could not find `#{spec}`#{" imported from #{from}" if from}. " \
-                                 "Looked in: #{Array(@config.paths).join(", ")}")
+      resolved = resolve(spec, from: from)
+      return resolved if resolved
+
+      raise FileNotFoundError, unresolvable(spec, from)
     end
 
     def import(spec, as: nil, from: nil)
@@ -170,6 +171,40 @@ module RSX
 
     private
 
+    def rsx_file_at(candidate)
+      return candidate if candidate.end_with?(".rsx") && File.file?(candidate)
+
+      EXTENSIONS.each do |extension|
+        with_extension = "#{candidate}#{extension}"
+        return with_extension if File.file?(with_extension)
+      end
+
+      nil
+    end
+
+    # Loading a template evaluates it, so resolution stays inside the configured
+    # paths (plus the working directory, which is what scripts and the CLI point
+    # at). Without this a spec that came from a request could name any file on
+    # disk. Paths are compared after expansion, so `../` cannot climb out.
+    def within_roots?(path)
+      target = File.expand_path(path)
+      roots.any? { |root| target == root || target.start_with?("#{root}#{File::SEPARATOR}") }
+    end
+
+    def roots
+      Array(@config.paths).map { |root| File.expand_path(root.to_s) }.push(File.expand_path(Dir.pwd)).uniq
+    end
+
+    def unresolvable(spec, from)
+      searched = Array(@config.paths).join(", ")
+      if rsx_file_at(File.expand_path(spec.to_s, Dir.pwd)) || rsx_file_at(spec.to_s)
+        "`#{spec}` is outside the configured RSX paths, so it will not be loaded. " \
+          "Add its directory to RSX.config.paths. Configured: #{searched}"
+      else
+        "could not find `#{spec}`#{" imported from #{from}" if from}. Looked in: #{searched}"
+      end
+    end
+
     def mtime(path)
       File.mtime(path)
     rescue SystemCallError
@@ -189,6 +224,7 @@ module RSX
       entry.components.each { |component| RSX.remove_constant(component) }
       entry.components.clear
       entry.default = nil
+      RSX.discard_statics(entry.statics_prefix)
     end
   end
 end

data/lib/rsx/nodes.rb

@@ -7,6 +7,9 @@ module RSX
     # Literal markup text, already whitespace-normalized JSX style.
     Text = Struct.new(:value, :line)
 
+    # The body of a raw text element (<script>, <style>), emitted byte for byte.
+    RawText = Struct.new(:value, :line)
+
     # {ruby} in child position.
     Expression = Struct.new(:source, :line)
 

data/lib/rsx/railtie.rb

@@ -30,6 +30,7 @@ module RSX
     initializer "rsx.action_view" do
       ActiveSupport.on_load(:action_view) do
         ActionView::Template.register_template_handler(:rsx, RSX::TemplateHandler)
+        RSX::TemplateHandler.register_dependency_tracker
         include RSX::Helpers
       end
     end

data/lib/rsx/template.rb

@@ -7,7 +7,7 @@ module RSX
   # template gets the whole component toolkit (children, caching, context,
   # helpers) and is compiled once no matter how often it is rendered.
   class Template
-    attr_reader :path, :digest
+    attr_reader :path, :digest, :component
 
     def self.load(path)
       absolute = File.expand_path(path)
@@ -22,7 +22,7 @@ module RSX
 
     def initialize(source, path: nil)
       digest = RSX.config.compile_cache.digest(source.to_s)
-      ruby = RSX.config.compile_cache.fetch(path || "template", source.to_s) do
+      ruby = RSX.config.compile_cache.fetch_or_compile(path || "template", source.to_s) do
         Transformer.transform(source.to_s, path: path)
       end
       build(ruby, path, digest)
@@ -40,10 +40,6 @@ module RSX
       end
     end
 
-    def component
-      @component
-    end
-
     private
 
     def build(ruby, path, digest)

data/lib/rsx/template_handler.rb

@@ -30,6 +30,38 @@ module RSX
       def handles_encoding?
         true
       end
+
+      # Rails builds a cache key for a template from the templates it renders, and
+      # finds those by compiling the template and looking for `render` calls in
+      # the result. Without a tracker for .rsx, a `cache` block wrapping an .rsx
+      # partial keeps serving the old markup after that partial changes.
+      #
+      # Since .rsx compiles to Ruby, Rails' own Ruby tracker needs nothing from
+      # us beyond being pointed at the extension.
+      # Call this after registering the handler: Rails keys trackers by handler,
+      # so the extension has to resolve to this one already.
+      def register_dependency_tracker
+        return false unless defined?(::ActionView)
+
+        require "action_view/dependency_tracker"
+        tracker = ruby_dependency_tracker
+        return false if tracker.nil?
+
+        ::ActionView::DependencyTracker.register_tracker(:rsx, tracker)
+        true
+      rescue ::LoadError
+        false
+      end
+
+      private
+
+      def ruby_dependency_tracker
+        %i[RubyTracker RipperTracker].each do |name|
+          registry = ::ActionView::DependencyTracker
+          return registry.const_get(name) if registry.const_defined?(name)
+        end
+        nil
+      end
     end
   end
 end

data/lib/rsx/transformer.rb

@@ -62,9 +62,16 @@ module RSX
       @pending_loop = false
       @jsx_spans = []
       @components = 0
-      # Static markup slots are keyed by a digest of the source, so recompiling
-      # the same file reuses the same slots instead of leaking new ones.
-      @codegen = Codegen.new(path: path, prefix: "#{Digest::SHA256.hexdigest(@src)[0, 10]}-")
+      @preformatted = 0
+      @codegen = Codegen.new(path: path, prefix: self.class.static_prefix(@src))
+    end
+
+    # Static markup slots are keyed by a digest of the source, so recompiling the
+    # same file reuses its slots rather than adding another set. Deriving the
+    # prefix from the source alone also lets the loader find and drop the slots
+    # belonging to a version of a file it is replacing.
+    def self.static_prefix(source)
+      "#{Digest::SHA256.hexdigest(source.to_s)[0, 10]}-"
     end
 
     def transform
@@ -189,6 +196,7 @@ module RSX
           elsif @prev == :start && jsx_ahead?
             emit_jsx
           else
+            reject_misplaced_markup
             copy_operator
           end
         when "/"
@@ -237,8 +245,10 @@ module RSX
     def copy_operator
       char = peek
 
-      # `::` and `?.`-like sequences are copied whole so state stays accurate.
-      if char == ":" && peek(1) == ":"
+      # `::`, and a `<<` that heredoc_ahead? already ruled out as a heredoc, are
+      # copied whole so state stays accurate. Leaving the second character behind
+      # would put it in expression position, where `list <<x` reads as a tag.
+      if (char == ":" && peek(1) == ":") || (char == "<" && peek(1) == "<")
         copy(2)
         @prev = :start
       elsif char == ":" && symbol_ahead?
@@ -255,10 +265,10 @@ module RSX
 
     def copy_number
       copy while !eof? && /[0-9a-zA-Z_]/.match?(peek)
-      if peek == "." && peek(1) && DIGIT.match?(peek(1))
-        copy
-        copy while !eof? && /[0-9a-zA-Z_]/.match?(peek)
-      end
+      return unless peek == "." && peek(1) && DIGIT.match?(peek(1))
+
+      copy
+      copy while !eof? && /[0-9a-zA-Z_]/.match?(peek)
     end
 
     def copy_line_comment
@@ -363,8 +373,10 @@ module RSX
         char = peek
         case char
         when "\\" then copy(2)
-        when "[" then in_class = true; copy
-        when "]" then in_class = false; copy
+        when "[" then in_class = true
+                      copy
+        when "]" then in_class = false
+                      copy
         when "#"
           if peek(1) == "{"
             copy(2)
@@ -410,7 +422,9 @@ module RSX
         return
       end
       copy while !eof? && (IDENT_CHAR.match?(peek) || peek == "@" || peek == "$")
-      copy if peek == "?" || peek == "!" || (peek == "=" && peek(1) != "=" && peek(1) != ">" && peek(1) != "~")
+      if peek == "?" || peek == "!" || (peek == "=" && peek(1) != "=" && peek(1) != ">" && peek(1) != "~")
+        copy
+      end
     end
 
     # ------------------------------------------------------------------
@@ -442,7 +456,7 @@ module RSX
       indented = peek == "~" || peek == "-"
       copy if indented
 
-      quote = (peek == '"' || peek == "'" || peek == "`") ? peek : nil
+      quote = peek == '"' || peek == "'" || peek == "`" ? peek : nil
       copy if quote
       identifier = +""
       while !eof? && IDENT_CHAR.match?(peek)
@@ -533,11 +547,13 @@ module RSX
         if BLOCK_KEYWORDS.key?(word)
           @blocks.push({ kind: :block, line: @line })
           @prev = :start
+        # Stated ahead of OPENS_EXPRESSION so the precedence between the two
+        # tables is visible, even though the fallthrough agrees with it.
         elsif CLOSES_EXPRESSION.key?(word)
           @prev = :value
         elsif OPENS_EXPRESSION.key?(word)
           @prev = :start
-        else
+        else # rubocop:disable Lint/DuplicateBranch
           @prev = :value
         end
       end
@@ -581,10 +597,12 @@ module RSX
       leftover.empty?
     end
 
+    METHOD_NAME_CHAR = %r{[A-Za-z0-9_.?!\[\]<>=+\-*/%&|^~]}
+
     def endless_def_ahead?
       offset = 0
       offset += 1 while @pos + offset < @len && /[ \t]/.match?(@src[@pos + offset])
-      offset += 1 while @pos + offset < @len && /[A-Za-z0-9_.?!\[\]<>=+\-*\/%&|^~]/.match?(@src[@pos + offset])
+      offset += 1 while @pos + offset < @len && METHOD_NAME_CHAR.match?(@src[@pos + offset])
 
       if @src[@pos + offset] == "("
         depth = 0
@@ -619,7 +637,7 @@ module RSX
         lowercase = /\Acomponent[ \t]+([a-z_][A-Za-z0-9_]*)/.match(@src[@pos..])
         if lowercase
           error("component names must be constants, got `#{lowercase[1]}` " \
-                "(try `component #{lowercase[1].split('_').map(&:capitalize).join}`)")
+                "(try `component #{lowercase[1].split("_").map(&:capitalize).join}`)")
         end
         return false
       end
@@ -654,17 +672,21 @@ module RSX
       until eof?
         char = peek
         case char
-        when "(", "[", "{" then depth += 1; advance
-        when ")", "]", "}" then depth -= 1; advance
+        when "(", "[", "{" then depth += 1
+                                advance
+        when ")", "]", "}" then depth -= 1
+                                advance
         when "'", '"'
           capture { copy_quoted(char) }
         when "#"
           advance until eof? || peek == "\n"
         when "d"
-          if depth.zero? && lookahead(2) == "do" && !identifier_char?(peek(2)) && !identifier_char?(@src[@pos - 1])
+          if depth.zero? && lookahead(2) == "do" &&
+             !identifier_char?(peek(2)) && !identifier_char?(@src[@pos - 1])
             options = @src[start...@pos].strip
             advance(2)
             return "" if options.empty?
+
             return options.start_with?(",") ? options : ", #{options}"
           end
           advance
@@ -692,8 +714,10 @@ module RSX
       until eof?
         char = peek
         case char
-        when "(", "[", "{" then depth += 1; advance
-        when ")", "]", "}" then depth -= 1; advance
+        when "(", "[", "{" then depth += 1
+                                advance
+        when ")", "]", "}" then depth -= 1
+                                advance
         when "'", '"' then capture { copy_quoted(char) }
         when "|"
           if depth.zero?
@@ -760,6 +784,27 @@ module RSX
       !after.nil? && TAG_START.match?(after)
     end
 
+    # A tag that opens and closes on one line, used only to recognise a mistake.
+    MISPLACED_MARKUP = %r{\A<([A-Za-z][A-Za-z0-9_\-.:]*)(?:[ \t]*/>|[^<>\n]*>)}
+
+    # `render <div>x</div>` is not markup to Ruby, it is a chain of comparisons,
+    # because a value already ended the expression. Left alone it compiles to
+    # something that fails far from the real mistake, so name it here instead.
+    #
+    # The check demands a space before `<` and none after, which is how markup is
+    # written and how comparisons are not, so `a < b` and `a<b` never reach it.
+    def reject_misplaced_markup
+      return unless @prev == :value
+      return unless /[ \t]/.match?(@src[@pos - 1].to_s)
+
+      match = MISPLACED_MARKUP.match(@src[@pos..])
+      return if match.nil?
+      return unless match[0].end_with?("/>") || @src.index("</#{match[1]}>", @pos)
+
+      error("markup here needs parentheses: `method(<#{match[1]} ... />)`. Ruby reads a " \
+            "`<` that follows a value as a comparison, so the markup never starts.")
+    end
+
     def emit_jsx
       start_pos = @pos
       start_line = @line
@@ -796,13 +841,60 @@ module RSX
       advance
 
       # Void elements are complete at ">": HTML gives them no closing tag.
-      return build_node(tag, attributes, [], true, line) if Attributes.void?(tag)
+      if Attributes.void?(tag)
+        reject_void_closing_tag(tag, line)
+        return build_node(tag, attributes, [], true, line)
+      end
+
+      children =
+        if Attributes.raw_text?(tag)
+          parse_raw_text(tag)
+        else
+          parse_element_children(tag)
+        end
 
-      children = parse_children(tag)
       expect_closing_tag(tag)
       build_node(tag, attributes, children, false, line)
     end
 
+    def parse_element_children(tag)
+      @preformatted += 1 if Attributes.preformatted?(tag)
+      parse_children(tag)
+    ensure
+      @preformatted -= 1 if Attributes.preformatted?(tag)
+    end
+
+    # The body of <script> or <style>. HTML treats these as raw text, so nothing
+    # inside is markup: `.a > .b`, `if (a < b)` and JavaScript object literals are
+    # all just characters. Dynamic content goes through dangerouslySetInnerHTML.
+    def parse_raw_text(tag)
+      start = @pos
+      start_line = @line
+      closing = "</#{tag}"
+
+      until eof?
+        break if peek == "<" && lookahead(closing.length).to_s.casecmp?(closing)
+
+        advance
+      end
+
+      error("unterminated <#{tag}> element", line: start_line) if eof?
+
+      body = @src[start...@pos]
+      body.empty? ? [] : [Nodes::RawText.new(body, start_line)]
+    end
+
+    # `<br>text</br>` parses as a complete <br> followed by `text</br>`, which is
+    # then copied out as Ruby and fails in the generated file instead of here.
+    def reject_void_closing_tag(tag, line)
+      index = @src.index("<", @pos)
+      return if index.nil?
+      return unless %r{\A</#{Regexp.escape(tag)}[ \t]*>}i.match?(@src[index..])
+
+      error("<#{tag}> is a void element: it takes no children and has no closing tag. " \
+            "Write `<#{tag} />`.", line: line)
+    end
+
     def build_node(tag, attributes, children, self_closing, line)
       if tag == "Fragment" || tag == "React.Fragment" || tag == "RSX::Fragment"
         return Nodes::Fragment.new(children, line)
@@ -840,9 +932,7 @@ module RSX
           next
         end
 
-        unless ATTR_START.match?(peek)
-          error("unexpected `#{peek}` in <#{tag}> attributes")
-        end
+        error("unexpected `#{peek}` in <#{tag}> attributes") unless ATTR_START.match?(peek)
 
         name = read_attribute_name
         skip_tag_whitespace
@@ -997,13 +1087,20 @@ module RSX
     def flush_text(children, text, line)
       return if text.empty?
 
-      normalized = self.class.normalize_text(text)
+      # Inside <pre> or <textarea> the browser shows whitespace as written, so
+      # collapsing it the way JSX does elsewhere would change the output.
+      if @preformatted.positive?
+        children << Nodes::Text.new(text, line)
+        return
+      end
+
+      normalized = normalize_text(text)
       children << Nodes::Text.new(normalized, line) unless normalized.empty?
     end
 
     # JSX whitespace rules: indentation-only lines disappear, and remaining lines
     # are joined with a single space.
-    def self.normalize_text(raw)
+    def normalize_text(raw)
       lines = raw.split("\n", -1)
       return lines.first.to_s if lines.length == 1
 
@@ -1028,7 +1125,7 @@ module RSX
       return if closing == tag
       return if tag == "" && closing == ""
 
-      error("closing tag `</#{closing}>` does not match opening tag `<#{tag.empty? ? '' : tag}>`")
+      error("closing tag `</#{closing}>` does not match opening tag `<#{tag unless tag.empty?}>`")
     end
   end
 end

data/lib/rsx/version.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 module RSX
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 
   # Bumping this invalidates every on-disk compile cache entry.
-  COMPILER_VERSION = "1"
+  COMPILER_VERSION = "2"
 end

data/lib/rsx.rb

@@ -31,7 +31,11 @@ module RSX
 
   # Slots for markup that never changes, populated on first render by compiled
   # templates. Keys are generated at compile time, one per call site.
-  STATICS = {}
+  #
+  # Compiled markup reads a slot directly and only calls define_static on a miss,
+  # so the render path is a bare Hash read and the lock is paid once per slot.
+  STATICS = {} # rubocop:disable Style/MutableConstant
+  STATICS_LOCK = Mutex.new
 
   # Configuration is intentionally small: where to find components, where to put
   # compiled output, and which cache to use.
@@ -138,7 +142,7 @@ module RSX
     def precompile!(paths = config.paths)
       loader.files(paths).each do |file|
         source = File.read(file)
-        config.compile_cache.fetch(file, source) { Transformer.transform(source, path: file) }
+        config.compile_cache.fetch_or_compile(file, source) { Transformer.transform(source, path: file) }
       end
     end
 
@@ -166,7 +170,7 @@ module RSX
 
     def render_file(path, context: nil, **props)
       entry = loader.load(loader.resolve!(path))
-      props = props.empty? ? nil : props
+      props = nil if props.empty?
       component = entry.renderable
 
       if component
@@ -188,10 +192,9 @@ module RSX
 
     # Internal: emitted by compiled markup for every <Component /> tag.
     def render_component(target, props = nil, children = nil, parent = nil)
-      if children
-        props = props ? props : {}
-        props[:children] = children
-      end
+      # Copied rather than written into, so that a caller holding the hash does
+      # not find :children added to it.
+      props = props ? props.merge(children: children) : { children: children } if children
 
       case target
       when Proc
@@ -254,9 +257,19 @@ module RSX
       end
     end
 
-    # Wraps markup that the compiler proved static. Called once per call site.
-    def static(literal)
-      SafeString.new(literal).freeze
+    # Internal: fills a static slot the first time its call site renders.
+    def define_static(key, literal)
+      STATICS_LOCK.synchronize { STATICS[key] ||= SafeString.new(literal).freeze }
+    end
+
+    # Internal: drops the slots belonging to one compiled version of a file.
+    # Editing a file in development compiles it under a fresh set of keys, and the
+    # old ones can never be reached again, so they would accumulate for the life
+    # of the process.
+    def discard_statics(prefix)
+      return if prefix.nil?
+
+      STATICS_LOCK.synchronize { STATICS.delete_if { |key, _| key.to_s.start_with?(prefix) } }
     end
 
     # Wraps an already-escaped or trusted string without copying when possible.
@@ -323,9 +336,7 @@ module RSX
     # Emitted by `export Name`.
     def export(component, from: nil)
       entry = loader.current_entry || (from && loader.entries.find { |candidate| candidate.path == from })
-      if entry && !entry.components.include?(component)
-        entry.components << component
-      end
+      entry.components << component if entry && !entry.components.include?(component)
       component
     end
 
@@ -372,7 +383,9 @@ module RSX
       parts = name.split("::")
       target = Object
       parts[0..-2].each do |part|
-        return unless target.const_defined?(part, false)
+        # Walking off the namespace means there is nothing to remove, which ends
+        # the method rather than the iteration.
+        return unless target.const_defined?(part, false) # rubocop:disable Lint/NonLocalExitFromIterator
 
         target = target.const_get(part, false)
       end
@@ -427,4 +440,4 @@ module RSX
   end
 end
 
-require_relative "rsx/railtie" if defined?(::Rails::Railtie)
+require_relative "rsx/railtie" if defined?(Rails::Railtie)

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: rsx-rb
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
-- RSX contributors
-autorequire:
+- Jason Brock
 bindir: exe
 cert_chain: []
-date: 2026-08-22 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
 description: |
   RSX is a template language that brings React's JSX authoring model to Ruby.
@@ -18,6 +17,7 @@ description: |
   plain Ruby string building, so rendering is fast and cacheable. Zero runtime
   dependencies; Rails integration is optional and loads automatically when present.
 email:
+- jasonallenbrock@gmail.com
 executables:
 - rsx
 extensions: []
@@ -34,6 +34,8 @@ files:
 - examples/user_profile.rsx
 - examples/views/dashboard.html.rsx
 - exe/rsx
+- lib/generators/rsx/component/component_generator.rb
+- lib/generators/rsx/component/templates/component.rsx.tt
 - lib/rsx-rb.rb
 - lib/rsx.rb
 - lib/rsx/attributes.rb
@@ -56,15 +58,14 @@ files:
 - lib/rsx/template_handler.rb
 - lib/rsx/transformer.rb
 - lib/rsx/version.rb
-homepage: https://github.com/rsx-rb/rsx
+homepage: https://github.com/derwydd/rsx
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://github.com/rsx-rb/rsx
-  source_code_uri: https://github.com/rsx-rb/rsx
-  changelog_uri: https://github.com/rsx-rb/rsx/blob/main/CHANGELOG.md
+  source_code_uri: https://github.com/derwydd/rsx
+  bug_tracker_uri: https://github.com/derwydd/rsx/issues
+  changelog_uri: https://github.com/derwydd/rsx/blob/main/CHANGELOG.md
   rubygems_mfa_required: 'true'
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -79,8 +80,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.3
-signing_key:
+rubygems_version: 4.0.20
 specification_version: 4
 summary: JSX-style templates for Ruby and Rails.
 test_files: []