actionview-vue_tag_helper 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 12f7b06e1478214f4dcd66a37e4e3b4aaa30dfe320968de3bfecd5197ca0ee5d
+  data.tar.gz: 7cd2b775fe4cd076cc6d7bda65368084fc8d934d9fa486dcc6cda379ba28c424
+SHA512:
+  metadata.gz: c3c40fedfabc6d3b1fb356b7b49383b56194acd2c7dd85558387b95db9da5ca70b7a24a03735bbb2d3f7fa4a9610cc91f3716f179ac18838b995c6df66d9a1b2
+  data.tar.gz: 586c97c37a9bf471442af409c943e7784a2381fc2b397feca23f7cd320e1e92fe7d7e4297c76adbb81ac6315f689720b21b3fa4b9c76a0905f29d84fe71a9799

data/CHANGELOG.md

@@ -0,0 +1,15 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+### Added
+
+Initial release.
+
+[unreleased]: https://github.com/dmke/actionview-vue_tag_helper/compare/v0.1.0...HEAD
+[0.1.0]: https://github.com/dmke/actionview-vue_tag_helper/releases/tag/v0.1.0

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Dominik Menke
+
+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,151 @@
+# actionview-vue_tag_helper
+
+An ActionView helper for embedding Vue components in server-rendered HTML,
+targeting the [Islands architecture](https://jasonformat.com/islands-architecture/):
+multiple independent Vue instances mounted on otherwise static pages,
+without a full SPA or SSR pipeline.
+
+## Overview
+
+In the Islands model, Rails delivers ordinary HTML and Vue is mounted on
+individual "islands" — interactive widgets that need typed props, reactive
+state, or component-library primitives. The built-in `tag` helper works
+fine for plain HTML but is a poor fit here: it always uses double-quote
+delimiters and entity-encodes `"` inside attribute values, turning a
+simple JSON prop into noise, and it has no concept of Vue's typed props
+or `v-bind` shorthand.
+
+`actionview-vue_tag_helper` provides a `vue` helper with the same
+builder interface but tuned for Vue component output:
+
+```erb
+<%# tag helper — double-quotes force &quot; encoding inside JSON %>
+<%= tag.my_component data: { config: {key: "val"}.to_json } %>
+<%# => <my-component data-config="{&quot;key&quot;:&quot;val&quot;}"></my-component> %>
+
+<%# vue helper — switches to single quotes when the value contains " %>
+<%= vue.my_component data: { config: {key: "val"} } %>
+<%# => <my-component data-config='{"key":"val"}'></my-component> %>
+```
+
+### Tag names
+
+Method names are dasherized: `vue.my_feed_item` and `vue.MyFeedItem`
+both produce `<my-feed-item>`. The resulting name must contain at least
+one hyphen (the HTML Living Standard requirement for custom element
+names). Anything that doesn't meet this — a plain word like `vue.div`,
+for example — raises `ArgumentError` immediately.
+
+Every tag is emitted with an explicit closing tag; Vue component tags are
+never self-closing.
+
+### Typed attributes / v-bind shorthand
+
+Vue components use typed props. Passing `count="42"` (a string) when the
+component declares `count: Number` triggers a Vue runtime warning. The
+`vue` helper avoids this by inspecting the Ruby value:
+
+| Ruby value | Emitted attribute |
+|:-----------|:------------------|
+| `String`, `Symbol` | `label="hello"` — plain attribute |
+| `true`             | `disabled` — valueless (Vue treats presence as truthy) |
+| `Integer`, `Float`, `false`, `Array`, `Hash`, … | `:count="42"` — v-bind shorthand, value serialised as JSON |
+
+```erb
+<%= vue.b_btn(disabled: true) %>
+<%# => <b-btn disabled></b-btn> %>
+
+<%= vue.x_counter(count: 42, ratio: 1.5) %>
+<%# => <x-counter :count="42" :ratio="1.5"></x-counter> %>
+
+<%= vue.my_component(items: %w[a b]) %>
+<%# => <my-component :items='["a","b"]'></my-component> %>
+```
+
+The `class:` key is exempt: an `Array` or `Hash` value is always
+flattened into a space-separated CSS token list, never v-bound.
+
+### `data:` and `aria:` hashes
+
+A Hash under `data:` or `aria:` is expanded into individual prefixed
+attributes. Complex values are serialised to JSON; `aria:` values are
+always plain strings (WAI-ARIA is string-based).
+
+```erb
+<%= vue.my_component(data: { user: { id: 1, name: "Alice" } }) %>
+<%# => <my-component data-user='{"id":1,"name":"Alice"}'></my-component> %>
+```
+
+## Installation
+
+Add to your `Gemfile`:
+
+```ruby
+gem "actionview-vue_tag_helper"
+```
+
+The helper is available in all views as soon as the gem is loaded. No
+`include` or initialiser is required — it hooks into ActionView via
+`ActiveSupport.on_load(:action_view)`.
+
+## Contributing
+
+Pull requests are welcome. Please always add a test with your changes.
+
+### Prerequisites
+
+- [rbenv](https://github.com/rbenv/rbenv) with the
+  [rbenv-gemset](https://github.com/jf/rbenv-gemset) plugin
+- Ruby 4.0 (`rbenv install 4.0`)
+
+The project uses local gemsets stored under `.gems/` (gitignored).
+`.ruby-version` and `.ruby-gemset` are already checked in, so rbenv
+picks up the right Ruby and gemset automatically when you `cd` into the
+project.
+
+### Setup
+
+```sh
+git clone https://github.com/dmke/actionview-vue_tag_helper
+cd actionview-vue_tag_helper
+bundle install   # installs into .gems/4.0/...
+```
+
+### Running the tests
+
+Against the default gemfile (Rails 8.1):
+
+```sh
+bundle exec rspec
+```
+
+Against all supported Rails versions:
+
+```sh
+bin/test
+```
+
+Each gemfile gets its own isolated gemset under `.gems/` (e.g.
+`.gems/rails_8_0`, `.gems/rails_8_1`, `.gems/rails_main`).
+
+### Updating dependencies
+
+```sh
+bin/bundle-all update
+```
+
+### Cleaning stale gems
+
+```sh
+bin/bundle-all clean --force
+```
+
+### Linting
+
+```sh
+bundle exec rubocop
+```
+
+## License
+
+MIT - see [LICENSE.txt](LICENSE.txt).

data/lib/actionview/vue_tag_helper/railtie.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "rails/railtie"
+
+module ActionView
+  module VueTagHelper
+    # Integrates the +vue+ view helper into Rails applications.
+    #
+    # When Rails is present this Railtie is required automatically and the
+    # helper is included into +ActionView::Base+ via the +:action_view+ load
+    # hook, which is the correct integration point for ActionView extensions.
+    class Railtie < Rails::Railtie
+      initializer "vue_tag_helper.action_view" do
+        ActiveSupport.on_load(:action_view) do
+          include ActionView::Helpers::VueTagHelper
+        end
+      end
+    end
+  end
+end

data/lib/actionview/vue_tag_helper/version.rb

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

data/lib/actionview/vue_tag_helper/vue_builder.rb

@@ -0,0 +1,357 @@
+# frozen_string_literal: true
+
+require "action_view"
+
+module ActionView
+  module Helpers
+    module TagHelper
+      # VueBuilder generates Vue component markup from a proxy-style builder
+      # interface identical to the built-in +tag+ helper:
+      #
+      # @example
+      #   vue.my_component(label: "Hello")
+      #   # => <my-component label="Hello"></my-component>
+      #
+      # It is intentionally *not* a subclass of TagBuilder.  The two helpers
+      # have different semantics and will diverge further as Vue-specific
+      # features are added.
+      #
+      # ## Tag names
+      #
+      # Method names are dasherized before use as the HTML tag name
+      # (+my_feed_item+ → +my-feed-item+).  The resulting name must be a valid
+      # kebab-cased custom-element name: all-lowercase, letters/digits only,
+      # and at least one hyphen separating two non-empty segments.  Anything
+      # else — PascalCase, a plain lowercase word, underscores — raises
+      # +ArgumentError+ immediately, before attributes or content are evaluated.
+      #
+      # @example
+      #   vue.my_component   # => <my-component></my-component>  ✓
+      #   vue.MyComponent    # => <my-component></my-component>  ✓  (PascalCase normalised)
+      #   vue.div            # => ArgumentError ("div")          ✗
+      #
+      # This mirrors the HTML Living Standard requirement that custom element
+      # names contain at least one hyphen, which also guarantees they can never
+      # collide with current or future built-in HTML elements.
+      #
+      # ## Closing tags
+      #
+      # Every tag is emitted with an explicit closing tag.  Vue component tags
+      # are never self-closing.
+      #
+      # ## Attribute quoting
+      #
+      # Standard TagBuilder always uses double-quote delimiters and escapes any
+      # literal +"+ inside a value as +&quot;+.  That is safe but verbose — a
+      # JSON blob like +{"key":"value"}+ becomes
+      # +data="{&quot;key&quot;:&quot;value&quot;}"+.
+      #
+      # VueBuilder switches to single-quote delimiters whenever the stringified
+      # value contains a double-quote, so the same blob is emitted as
+      # +data='{"key":"value"}'+.  The delimiter decision is independent
+      # of the +escape:+ flag.
+      #
+      # Escaping rules when single-quote delimiters are chosen:
+      #
+      #   &  →  &amp;
+      #   <  →  &lt;
+      #   >  →  &gt;
+      #   '  →  &#39;   (protects the delimiter)
+      #   "  →  (unchanged — the whole point)
+      #
+      # Values already marked +html_safe?+ are passed through as-is except that
+      # a literal +\'+ is escaped when single-quote delimiters are in use.
+      #
+      # ## Typed attributes / v-bind shorthand
+      #
+      # Vue components use typed props (+defineProps<{ count: number }>()+).
+      # Passing a plain HTML string like +count="42"+ triggers a Vue runtime
+      # warning because the prop expects a Number, not a String.
+      #
+      # VueBuilder avoids this by inspecting the Ruby value type:
+      #
+      # - +String+ / +Symbol+ — emitted as a plain attribute (no colon).
+      # - +true+ — emitted as a valueless attribute (+disabled+).  Vue
+      #   interprets attribute presence as a truthy boolean.
+      # - everything else (+Integer+, +Float+, +BigDecimal+, +false+,
+      #   +Array+, +Hash+, …) — the attribute name is prefixed with +:+
+      #   (the +v-bind+ shorthand) and the value is serialised with
+      #   +#to_json+.  The resulting JSON string is then subject to the
+      #   normal single/double-quote quoting rules.
+      #
+      # @example
+      #   vue.my_component(count: 42)
+      #   # => <my-component :count="42"></my-component>
+      #
+      #   vue.my_component(items: ["a", "b"])
+      #   # => <my-component :items='["a","b"]'></my-component>
+      #
+      #   vue.b_btn(disabled: true)
+      #   # => <b-btn disabled></b-btn>
+      #
+      #   vue.b_btn(disabled: false)
+      #   # => <b-btn :disabled="false"></b-btn>
+      #
+      # The +class:+ key is exempt from the v-bind rule: an Array or Hash
+      # value is always flattened into a space-separated CSS token list.
+      #
+      # ## data: and aria: hashes
+      #
+      # A Hash passed under the +data:+ or +aria:+ key is expanded into
+      # individual prefixed attributes.  Values are serialised as follows:
+      #
+      # - +String+, +Symbol+ — passed through unchanged.
+      # - +BigDecimal+ — converted with +to_s("F")+ (fixed-point notation,
+      #   independent of any ActiveSupport monkey-patches).
+      # - everything else — serialised with +#to_json+.
+      #
+      # @example
+      #   vue.my_component(data: {items: ["a", "b"]})
+      #   # => <my-component data-items='["a","b"]'></my-component>
+      #
+      class VueBuilder
+        # Raised when a method name cannot be normalised to a valid kebab-cased
+        # Vue component tag name (i.e. one containing at least one hyphen).
+        #
+        # Inherits from +ArgumentError+ so existing rescues on +ArgumentError+
+        # continue to work.
+        #
+        # @param original [String] the method name as called (pre-normalisation)
+        # @param normalised [String] the name after +.underscore.dasherize+
+        class InvalidTagNameError < ArgumentError
+          def initialize(original, normalised = original)
+            detail = if original == normalised
+              original.inspect
+            else
+              "#{original.inspect} (normalised to #{normalised.inspect})"
+            end
+
+            super(<<~MESSAGE.strip)
+              Vue component tag names must be kebab-cased with at least one hyphen
+              (e.g. "my-component"), got: #{detail}
+            MESSAGE
+          end
+        end
+
+        # Valid Vue/custom-element tag name after dasherization:
+        # lowercase segments of letters and digits joined by hyphens, with at
+        # least one hyphen present.
+        KEBAB_TAG_RE = /\A[a-z][a-z0-9]*(-[a-z0-9]+)+\z/
+        private_constant :KEBAB_TAG_RE
+
+        # Characters that need escaping inside single-quoted HTML attributes.
+        # Note the deliberate absence of +" +: it is safe unescaped when the
+        # delimiter is a single quote.
+        SINGLE_QUOTE_ATTR_ESCAPE = {
+          "&" => "&amp;",
+          "<" => "&lt;",
+          ">" => "&gt;",
+          "'" => "&#39;",
+        }.freeze
+        private_constant :SINGLE_QUOTE_ATTR_ESCAPE
+
+        def initialize(view_context)
+          @view_context = view_context
+        end
+
+        private
+
+        def respond_to_missing?(*, **)
+          true
+        end
+
+        def method_missing(called, *args, escape: true, **options, &)
+          original = called.name
+          name     = original.underscore.dasherize
+          raise InvalidTagNameError.new(original, name) unless KEBAB_TAG_RE.match?(name)
+
+          content  = build_inline_content(args, escape, &)
+          "<#{name}#{build_tag_options(options, escape)}>#{content}</#{name}>".html_safe # rubocop:disable Rails/OutputSafety
+        end
+
+        def build_inline_content(args, escape, &block)
+          return @view_context.capture(self, &block) if block
+
+          args.first&.then { |i| escape ? ERB::Util.unwrapped_html_escape(i) : i.to_s }
+        end
+
+        # Serialises the options hash to an HTML attribute string.
+        #
+        # +data:+ and +aria:+ sub-hashes are expanded into prefixed attributes.
+        # All other key/value pairs are forwarded to +typed_tag_option+.
+        # +nil+ values are always omitted.
+        #
+        # @param options [Hash]
+        # @param escape [Boolean]
+        # @return [String, nil]
+        def build_tag_options(options, escape)
+          return if options.blank?
+
+          output = +""
+          options.each_pair { |k, v| append_one_option(output, k, v, escape) }
+          output unless output.empty?
+        end
+
+        def append_one_option(output, key, value, escape)
+          return if key.blank?
+
+          case key.to_s
+          when "data"
+            value.is_a?(Hash) && append_data_options(output, value, escape)
+          when "aria"
+            value.is_a?(Hash) && append_aria_options(output, value, escape)
+          else
+            output << " " << typed_tag_option(key, value, escape) unless value.nil?
+          end
+        end
+
+        def append_data_options(output, hash, escape)
+          hash.each_pair do |k, v|
+            output << " " << prefix_tag_option("data", k, v, escape) unless k.blank? || v.nil?
+          end
+        end
+
+        def append_aria_options(output, hash, escape)
+          hash.each_pair do |k, v|
+            next if k.blank? || v.nil?
+
+            v = resolve_aria_value(v)
+            output << " " << prefix_tag_option("aria", k, v, escape) unless v.nil?
+          end
+        end
+
+        def resolve_aria_value(value)
+          case value
+          when Array, Hash
+            tokens = TagHelper.build_tag_values(value)
+            tokens.any? ? @view_context.safe_join(tokens, " ") : nil
+          else
+            value.to_s
+          end
+        end
+
+        # Applies Vue-aware typing rules before delegating to +tag_option+.
+        #
+        # - +true+ — emits a valueless attribute (e.g. +disabled+).
+        # - +String+, +Symbol+ — passes through to +tag_option+ unchanged; no colon prefix.
+        # - +Array+, +Hash+ under +class:+ — passes through for CSS token-list expansion.
+        # - everything else — prepends +:+ to the key (v-bind shorthand) and serialises
+        #   the value with +#to_json+, then passes to +tag_option+.
+        def typed_tag_option(key, value, escape)
+          case value
+          when true
+            escape ? ERB::Util.xml_name_escape(key.to_s) : key.to_s
+          when String, Symbol
+            tag_option(key, value, escape)
+          when Array, Hash
+            key.to_s == "class" ? tag_option(key, value, escape) : tag_option(":#{key}", value.to_json, escape)
+          else
+            tag_option(":#{key}", value.to_json, escape)
+          end
+        end
+
+        # Serialises a +data-*+ or +aria-*+ attribute.
+        #
+        # - +String+, +Symbol+ — passed through unchanged.
+        # - +BigDecimal+ — converted with +to_s("F")+ (fixed-point notation, no
+        #   ActiveSupport dependency).  Using +to_json+ would produce a
+        #   JSON-encoded string literal (+'"3.14"'+) rather than a plain decimal
+        #   string (++"3.14"++); using bare +to_s+ without the format argument
+        #   produces scientific notation (++"0.314e1"++) in plain Ruby.
+        # - everything else — serialised with +#to_json+.
+        #
+        # @param prefix [String] +"data"+ or +"aria"+
+        # @param key [#to_s]
+        # @param value [Object]
+        # @param escape [Boolean]
+        # @return [String]
+        def prefix_tag_option(prefix, key, value, escape)
+          attr_key = "#{prefix}-#{key.to_s.dasherize}"
+          value    = case value
+          when String, Symbol
+            value
+          when BigDecimal
+            value.to_s("F")
+          else
+            value.to_json
+          end
+          tag_option(attr_key, value, escape)
+        end
+
+        # Serialises a single attribute key/value pair.
+        #
+        # Arrays and Hashes under a +class+ key are flattened to a
+        # space-separated token list with double-quote delimiters.  All other
+        # values go through +build_quoted_attr+ for the single/double-quote
+        # delimiter decision.
+        #
+        # @param key [String]
+        # @param value [Object]
+        # @param escape [Boolean]
+        # @return [String]
+        def tag_option(key, value, escape)
+          key = ERB::Util.xml_name_escape(key.to_s) if escape
+          case value
+          when Array, Hash
+            token_list_attr(key, value, escape)
+          when Regexp
+            build_quoted_attr(key, value.source, escape)
+          else
+            build_quoted_attr(key, value.to_s, escape)
+          end
+        end
+
+        def token_list_attr(key, value, escape)
+          value = TagHelper.build_tag_values(value) if key == "class"
+          value = escape ? @view_context.safe_join(value, " ") : value.join(" ")
+          value = value.gsub('"', "&quot;") if value.include?('"')
+          %(#{key}="#{value}")
+        end
+
+        # Chooses single-quote or double-quote delimiters based solely on
+        # whether +raw+ contains a double-quote character, then escapes and
+        # wraps the value.
+        #
+        # The delimiter choice is independent of +escape+: it is a structural
+        # concern (preventing attribute breakage), not a safety one.
+        #
+        # +raw+ must already be a String.  If it is +html_safe?+, the
+        # escaping step is skipped on the double-quote path (mirroring
+        # +ERB::Util.unwrapped_html_escape+) and reduced to +\'+ escaping only
+        # on the single-quote path.
+        #
+        # @param key [String]
+        # @param raw [String]
+        # @param escape [Boolean]
+        # @return [String]
+        def build_quoted_attr(key, raw, escape)
+          if raw.include?('"')
+            escaped = escape ? escape_for_single_quoted_attr(raw) : raw
+            %(#{key}='#{escaped}')
+          else
+            value = escape ? ERB::Util.unwrapped_html_escape(raw) : raw
+            value = value.gsub('"', "&quot;") if value.include?('"')
+            %(#{key}="#{value}")
+          end
+        end
+
+        # Escapes +str+ for embedding in a single-quoted HTML attribute.
+        #
+        # For +html_safe?+ strings, only the single-quote delimiter character
+        # is escaped — the caller is responsible for the rest of the content.
+        # For plain strings, +&+, +<+, +>+, and +'+ are all escaped; +"+ is
+        # intentionally left as-is.
+        #
+        # @param str [String]
+        # @return [String]
+        def escape_for_single_quoted_attr(str)
+          if str.html_safe?
+            str.include?("'") ? str.gsub("'", "&#39;") : str
+          else
+            str.gsub(/[&<>']/, SINGLE_QUOTE_ATTR_ESCAPE)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/actionview/vue_tag_helper.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "action_view"
+require "bigdecimal"
+require "active_support/core_ext/object/json"
+require_relative "vue_tag_helper/version"
+require_relative "vue_tag_helper/vue_builder"
+
+module ActionView
+  module Helpers
+    # Provides the +vue+ view helper, a sibling of the built-in +tag+ helper
+    # tuned for rendering Vue component markup.
+    #
+    # See ActionView::Helpers::TagHelper::VueBuilder for full documentation on
+    # how attribute quoting differs from the standard TagBuilder.
+    #
+    # @example
+    #   vue.MyComponent(label: "Hello", data: {items: [{id: 1}]})
+    #   # => <my-component label="Hello" data-items='[{"id":1}]'></my-component>
+    #
+    module VueTagHelper
+      # Returns the VueBuilder proxy for this view context.
+      #
+      # Every call within the same render cycle returns the same instance,
+      # mirroring how +tag+ works.
+      #
+      # @return [ActionView::Helpers::TagHelper::VueBuilder]
+      def vue
+        @vue ||= TagHelper::VueBuilder.new(self)
+      end
+    end
+  end
+end
+
+if defined?(Rails::Railtie)
+  require_relative "vue_tag_helper/railtie"
+else
+  ActiveSupport.on_load(:action_view) { include ActionView::Helpers::VueTagHelper }
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification
+name: actionview-vue_tag_helper
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Dominik Menke
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: actionview
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '8.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '8.0'
+description: |
+  Extends ActionView with a `vue` helper for the Islands architecture: Vue
+  components mounted on otherwise static, server-rendered pages. Unlike the
+  built-in `tag` helper, it emits v-bind shorthand for typed props, switches
+  to single-quote attribute delimiters when values contain double quotes (e.g.
+  JSON), and validates that tag names are legal kebab-cased custom element names.
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/actionview/vue_tag_helper.rb
+- lib/actionview/vue_tag_helper/railtie.rb
+- lib/actionview/vue_tag_helper/version.rb
+- lib/actionview/vue_tag_helper/vue_builder.rb
+homepage: https://github.com/dmke/actionview-vue_tag_helper
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+  homepage_uri: https://github.com/dmke/actionview-vue_tag_helper
+  source_code_uri: https://github.com/dmke/actionview-vue_tag_helper
+  bug_tracker_uri: https://github.com/dmke/actionview-vue_tag_helper/issues
+  changelog_uri: https://github.com/dmke/actionview-vue_tag_helper/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '4.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.6
+specification_version: 4
+summary: ActionView helper for embedding Vue component islands in server-rendered
+  HTML
+test_files: []