tuix_rails 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: dd2c3676824936348b36faf27edba0191067f31a2d2ecce7c5d5e4f33b05178d
+  data.tar.gz: 1be22f93ab08113a150736b9a2d7726076a36481c756c8edbbf0af2e2e87e190
+SHA512:
+  metadata.gz: 6a58fd4728e42ef4be71e8bec5e623245319d819e716e81778d2eca5a8ae4c17da31cfcc28c8c6f484285f46093008d6d71f82e8cf077630618544905ebcb576
+  data.tar.gz: ca64d02cb52fce897c1f9610976d4b92ec0f1c4f9408aaec4b18b1978d8ecb0f82d1a4061e44a95ca44c22debd1dd4328766418aceb862b9ed0a3c40ecf53b78

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Maciek Wciślik
+
+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 @@
+# tuix_rails
+
+Rails integration for the existing Tuix widget: server-signed identities, hosted
+widget delivery, CSP nonces and Turbo navigation. Requires Ruby 3.2+ and Rails
+7.2–8.x (Rails itself may require a newer Ruby). No database, npm installation,
+asset precompile or separate Tuix login is needed by the host application.
+
+MIT licensed. Until the gem is on RubyGems, install it from a checkout of this
+repository or from a built gem, as below.
+
+## Install
+
+Add the package to the host application's Gemfile, using a checkout of this
+repository or an unpacked gem artifact:
+
+```ruby
+gem "tuix_rails", path: "/absolute/path/to/tuix/packages/rails"
+```
+
+For the built artifact, run `gem unpack output/releases/tuix_rails-0.1.0.gem`
+and point `path:` at the resulting `tuix_rails-0.1.0` directory.
+
+```sh
+bundle install
+bin/rails generate tuix:install
+```
+
+The generator creates `config/initializers/tuix.rb`. It prints the layout steps
+instead of guessing your authentication library or rewriting custom layouts.
+Re-running it uses Rails' normal file conflict handling; `--skip` preserves a
+custom initializer.
+
+Set `TUIX_PROJECT_KEY`, `TUIX_SECRET_KEY`, `TUIX_API_URL` (default
+`https://tuix.app`) and `TUIX_ENVIRONMENT` (default `uat`) on the host server.
+Allow the host's exact origin in Tuix project settings and keep signed identity
+enabled. HTTP API origins are accepted only for localhost/127.0.0.1 development.
+
+Add the asset helper inside your layout's `<head>`:
+
+```erb
+<%= tuix_assets %>
+```
+
+Add one identity helper inside `<body>`, outside any fragment shared across users:
+
+```erb
+<%= tuix_widget(user: current_user && {
+  id: current_user.id,
+  name: current_user.name,
+  email: current_user.email
+}) %>
+```
+
+Adapt `current_user` to your authentication system. Pass `nil` for signed-out
+users or users who should not have feedback access. Supply only trusted server
+identity data, never request parameters. Include email only when your application
+has verified it. Tuix uses the signed email for dashboard access and notifications;
+omit it if you cannot vouch for the address. IDs must be stable strings or integers.
+
+The gem signs the exact ID with HMAC-SHA256, or the ID, a newline and the trimmed,
+lowercased email when present (Tuix identity v2). The signing secret never goes
+into HTML. `TuixRails.identity(user)` is also available to sign identities for a
+separate JavaScript frontend. `config.release` optionally identifies a deployed
+build. Missing project/secret or an anonymous user leaves the widget inactive;
+invalid supplied configuration or identity raises an actionable argument error.
+
+## Navigation and delivery
+
+The gem serves its small bootstrap at a content-addressed `/tuix-rails/` URL.
+Authenticated pages fetch the configured Tuix origin's public
+`/widget/channels/stable.json` without cookies, validate the manifest, then load
+the immutable widget with SHA-384 integrity. One runtime is selected per document.
+Widget updates arrive on a subsequent full page load without upgrading the gem.
+Bootstrap changes require upgrading the gem and deploying the host.
+
+Turbo renders, frames and streams can replace the identity element. The bridge
+destroys the old widget before identifying the new user. Removing the element or
+rendering `user: nil` clears it. Pending loads cannot re-identify after logout.
+The bridge has bounded manifest/script timeouts and retries after navigation.
+Anonymous pages do not request the manifest or widget runtime.
+
+Before Turbo caches a page, the bridge removes its widget and signed identity.
+Cached previews stay inactive; a fresh server render restores feedback. A history
+restoration served entirely from Turbo's cache therefore has no feedback identity.
+For authenticated pages that need feedback on every back/forward visit, add this
+to the layout's `<head>` so Turbo fetches fresh server identity:
+
+```html
+<meta name="turbo-cache-control" content="no-cache">
+```
+
+Clear your application's Turbo cache on logout as part of its normal session
+handling. Do not mark the identity element `data-turbo-permanent` or put it in a
+shared full-page cache. Browser back/forward cache follows the host's existing
+session policy; the bridge destroys the widget on `pagehide` and re-reads the
+current page on `pageshow`. See the [Turbo lifecycle documentation](https://turbo.hotwired.dev/handbook/building).
+
+## Content security policy
+
+Helpers use Rails' `content_security_policy_nonce` by default; an explicit
+`nonce:` can be passed to both. The bootstrap passes it to the widget loader and
+styles. Keep the nonce consistent with the document's policy across Turbo visits.
+Keep Rails' `<%= csp_meta_tag %>` in the layout head so Turbo can also use that
+nonce for its own scripts and progress styles. The gem does not replace the host's policy.
+
+Allow the local bootstrap and the Tuix origin in applicable script directives,
+Tuix fonts, Tuix HTTP/WebSocket connections (including manifest fetches), and
+the storage origin shown in Project settings for uploads and images. Image
+previews need `blob:` and `data:`. Capture requires `style-src-attr 'unsafe-inline'`
+and the empty stylesheet hash
+`'sha256-47DEQpj8HBSa+/TImW+5JCeuQeRkm5NMpJWZG3hSuFU='` in the applicable style
+directive. Account for `script-src-elem`/`style-src-elem` when present. Test capture
+against the real host policy; Tuix → Project settings → Install tuix → Content
+Security Policy lists the exact sources for your project.
+
+## Development
+
+```sh
+cd packages/rails
+bundle install
+bundle exec ruby -Ilib test/integration_test.rb
+bundle exec ruby ../../scripts/package-rails.rb
+# From the repository root, after npm ci:
+npm test -w @tuix/rails
+npm run build -w @tuix/widget
+npm run test:browser -w @tuix/rails
+```
+
+`RAILS_VERSION='~> 7.2.0' bundle update` selects a different supported Rails line.
+CI covers Rails 7.2/Ruby 3.2, Rails 8.0/Ruby 3.3 and Rails 8.1/Ruby 3.4.
+Integration tests boot a real Rails application, render helpers, fetch the asset
+through middleware, check identity signing/escaping, and exercise the generator.
+The package command builds `output/releases/tuix_rails-0.1.0.gem`, verifies its
+contents and reruns integration tests against a temporary gem installation before copying
+the artifact into place. It never publishes. CI uploads the same local artifact, and the
+release workflow publishes that artifact.
+
+Browser regression tests need Playwright Chromium (`npx playwright install chromium`).
+They boot Rails on loopback and exercise the actual Turbo library and built Tuix
+widget: Drive, frames, streams, logout, back navigation, CSP nonces and SRI rejection.
+The remote Tuix API is a deterministic local fixture that verifies Ruby signatures
+with an independent Node HMAC implementation. jsdom tests cover pending-load races
+and recovery. No store/account, Docker or production keys are needed.
+
+Locally verified on 11 October 2026 with Ruby 3.2.4: all 9 integration tests passed
+on Rails 7.2.4, 8.0.5.1 and 8.1.4; all 8 bootstrap tests and the Chromium/Turbo
+8.0.23 browser smoke passed. The CI matrix also exercises newer Ruby versions;
+its remote run is separate from these local results.
+
+Before rolling out to your users, try report creation, screenshots and notifications
+against a real Tuix project using the host's authentication, origin and CSP.

data/assets/bootstrap.js

@@ -0,0 +1,143 @@
+/* A page selects one runtime. Signed identity follows Rails renders and Turbo navigation. */
+(() => {
+  const root = document.documentElement;
+  if (root.hasAttribute('data-tuix-rails-bound')) return;
+  root.setAttribute('data-tuix-rails-bound', '');
+  const sri = /^sha384-[A-Za-z0-9+/]{64}$/;
+  const immutable = /^\/widget\/(\d+\.\d+\.\d+(?:-[a-zA-Z0-9.-]+)?)\/[a-f0-9]{64}\/tuix\.js$/;
+  let previous, failed, selected, loading, controller;
+  let generation = 0;
+  let suspended = false;
+
+  function clear() {
+    generation++;
+    controller?.abort();
+    controller = undefined;
+    if (previous !== undefined && typeof window.tuix === 'function') window.tuix('destroy');
+    previous = undefined;
+  }
+
+  function apiOrigin(value) {
+    const url = new URL(value);
+    if (url.username || url.password || url.search || url.hash ||
+        !['', '/'].includes(url.pathname) ||
+        !(url.protocol === 'https:' || (url.protocol === 'http:' && ['localhost', '127.0.0.1'].includes(url.hostname)))) {
+      throw Error('Invalid Tuix API origin');
+    }
+    return url.origin;
+  }
+
+  function runtime(manifest, origin) {
+    const match = typeof manifest?.loader?.url === 'string' && manifest.loader.url.match(immutable);
+    if (manifest?.protocol !== 1 || !match || manifest.version !== match[1] ||
+        !sri.test(manifest.loader.integrity) ||
+        (manifest.directory !== undefined && manifest.directory !== manifest.loader.url.slice(8, -8))) {
+      throw Error('Invalid Tuix runtime manifest');
+    }
+    return { url: origin + manifest.loader.url, integrity: manifest.loader.integrity };
+  }
+
+  async function select(payload, token) {
+    const origin = apiOrigin(payload.options.api);
+    if (selected) {
+      if (selected.origin !== origin || selected.delivery !== payload.delivery) throw Error('Runtime already selected');
+      return selected;
+    }
+    let entry;
+    if (payload.delivery === 'hosted') {
+      const abort = new AbortController();
+      controller = abort;
+      const timeout = setTimeout(() => abort.abort(), 8000);
+      try {
+        const response = await fetch(origin + '/widget/channels/stable.json', {
+          mode: 'cors', credentials: 'omit', redirect: 'error', signal: abort.signal
+        });
+        if (!response.ok) throw Error('Runtime unavailable');
+        entry = runtime(await response.json(), origin);
+      } finally {
+        clearTimeout(timeout);
+        if (controller === abort) controller = undefined;
+      }
+    } else {
+      throw Error('Invalid delivery mode');
+    }
+    if (token !== generation) throw Error('Identity changed');
+    selected = { ...entry, origin, delivery: payload.delivery };
+    return selected;
+  }
+
+  function load(entry, nonce) {
+    if (loading) return loading;
+    loading = new Promise((resolve, reject) => {
+      const script = document.createElement('script');
+      script.src = entry.url;
+      script.integrity = entry.integrity;
+      script.crossOrigin = 'anonymous';
+      if (nonce) script.nonce = nonce;
+      const timeout = setTimeout(() => finish(false), 15000);
+      function finish(ok) {
+        clearTimeout(timeout);
+        script.onload = script.onerror = null;
+        if (ok) resolve();
+        else { script.remove(); loading = undefined; reject(Error('Runtime failed')); }
+      }
+      script.onload = () => finish(true);
+      script.onerror = () => finish(false);
+      document.head.append(script);
+    });
+    return loading;
+  }
+
+  async function synchronize() {
+    if (suspended || root.hasAttribute('data-turbo-preview')) return;
+    const encoded = document.getElementById('tuix-rails')?.getAttribute('data-tuix-rails');
+    if (!encoded) { if (previous !== undefined) clear(); return; }
+    if (encoded === previous || encoded === failed) return;
+    clear();
+    let payload;
+    try {
+      payload = JSON.parse(encoded);
+      if (!payload?.user?.id || !payload.user.name || !/^[a-f0-9]{64}$/.test(payload.user.hash) ||
+          !payload.options?.project) return;
+    } catch { return; }
+    previous = encoded;
+    const token = generation;
+    try {
+      const entry = await select(payload, token);
+      if (token !== generation) return;
+      await load(entry, payload.options.nonce);
+      if (token !== generation || suspended) return;
+      if (typeof window.tuix !== 'function') throw Error('Runtime missing');
+      window.tuix('destroy');
+      window.tuix('init', payload.options);
+      window.tuix('identify', payload.user);
+    } catch {
+      if (token !== generation) return;
+      failed = encoded;
+      clear();
+    }
+  }
+
+  let pending = false;
+  function schedule() {
+    if (pending) return;
+    pending = true;
+    queueMicrotask(() => { pending = false; synchronize(); });
+  }
+  new MutationObserver(schedule).observe(root, {
+    childList: true, subtree: true, attributes: true, attributeFilter: ['data-tuix-rails']
+  });
+  function navigate() { failed = undefined; schedule(); }
+  // Stop before Turbo clones the page. Signed identity must not survive in its cache.
+  document.addEventListener('turbo:before-cache', () => {
+    suspended = true;
+    clear();
+    document.getElementById('tuix-rails')?.removeAttribute('data-tuix-rails');
+  });
+  document.addEventListener('turbo:before-render', () => { suspended = true; clear(); });
+  document.addEventListener('turbo:load', () => { suspended = false; navigate(); });
+  document.addEventListener('turbo:render', () => { suspended = false; navigate(); });
+  window.addEventListener('pagehide', () => { suspended = true; clear(); });
+  window.addEventListener('pageshow', () => { suspended = false; navigate(); });
+  synchronize();
+})();

data/lib/generators/tuix/install_generator.rb

@@ -0,0 +1,26 @@
+require "rails/generators"
+
+module Tuix
+  class InstallGenerator < Rails::Generators::Base
+    desc "Configure Tuix and print the layout integration steps"
+
+    def create_configuration
+      initializer "tuix.rb", <<~RUBY
+        TuixRails.configure do |config|
+          config.project = ENV["TUIX_PROJECT_KEY"]
+          config.secret = ENV["TUIX_SECRET_KEY"]
+          config.api = ENV.fetch("TUIX_API_URL", "https://tuix.app")
+          config.environment = ENV.fetch("TUIX_ENVIRONMENT", "uat")
+          # config.release = ENV["APP_REVISION"]
+        end
+      RUBY
+    end
+
+    def installation_steps
+      say "Add <%= tuix_assets %> to your layout's <head>."
+      say "Add <%= tuix_widget(user: your_authenticated_identity_or_nil) %> inside <body>."
+      say "Use a hash with :id, :name and optional verified :email. Never use request parameters."
+      say "See the gem README for Turbo cache, CSP and allowed-origin configuration."
+    end
+  end
+end

data/lib/tuix_rails/assets.rb

@@ -0,0 +1,29 @@
+require "digest"
+require "base64"
+
+module TuixRails
+  module Assets
+    BODY = File.binread(File.expand_path("../../assets/bootstrap.js", __dir__)).freeze
+    PATH = "/tuix-rails/#{Digest::SHA256.hexdigest(BODY)}/bootstrap.js".freeze
+    INTEGRITY = "sha384-#{Base64.strict_encode64(Digest::SHA384.digest(BODY))}".freeze
+  end
+
+  # Serve exactly one public asset; no filesystem path comes from the request.
+  class Middleware
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      return @app.call(env) unless env["PATH_INFO"] == Assets::PATH && %w[GET HEAD].include?(env["REQUEST_METHOD"])
+      headers = {
+        "content-type" => "text/javascript; charset=utf-8",
+        "content-length" => Assets::BODY.bytesize.to_s,
+        "cache-control" => "public, max-age=31536000, immutable",
+        "x-content-type-options" => "nosniff",
+        "cross-origin-resource-policy" => "same-origin"
+      }
+      [200, headers, env["REQUEST_METHOD"] == "HEAD" ? [] : [Assets::BODY]]
+    end
+  end
+end

data/lib/tuix_rails/helper.rb

@@ -0,0 +1,18 @@
+require_relative "assets"
+
+module TuixRails
+  module Helper
+    def tuix_assets(nonce: content_security_policy_nonce)
+      path = "#{request.script_name}#{Assets::PATH}"
+      content_tag(:script, "", src: path, defer: true, integrity: Assets::INTEGRITY,
+        crossorigin: "anonymous", nonce: nonce, data: { turbo_track: "reload" })
+    end
+
+    def tuix_widget(user:, nonce: content_security_policy_nonce)
+      payload = TuixRails.payload(user, nonce: nonce)
+      # Action View escapes JSON as attribute text, including quotes and HTML.
+      content_tag(:div, "", id: "tuix-rails", hidden: true,
+        data: { tuix_rails: payload && JSON.generate(payload), turbo_temporary: true })
+    end
+  end
+end

data/lib/tuix_rails/railtie.rb

@@ -0,0 +1,13 @@
+require_relative "helper"
+
+module TuixRails
+  class Railtie < Rails::Railtie
+    initializer "tuix_rails.assets" do |app|
+      app.middleware.use TuixRails::Middleware
+    end
+
+    initializer "tuix_rails.helpers" do
+      ActiveSupport.on_load(:action_view) { include TuixRails::Helper }
+    end
+  end
+end

data/lib/tuix_rails/version.rb

@@ -0,0 +1,3 @@
+module TuixRails
+  VERSION = "0.1.0"
+end

data/lib/tuix_rails.rb

@@ -0,0 +1,81 @@
+require "json"
+require "openssl"
+require "uri"
+require_relative "tuix_rails/version"
+
+module TuixRails
+  class Configuration
+    attr_accessor :project, :secret, :api, :environment, :release
+
+    def initialize
+      @project = ENV["TUIX_PROJECT_KEY"]
+      @secret = ENV["TUIX_SECRET_KEY"]
+      @api = ENV.fetch("TUIX_API_URL", "https://tuix.app")
+      @environment = ENV.fetch("TUIX_ENVIRONMENT", "uat")
+    end
+  end
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.configure
+    yield configuration
+  end
+
+  def self.validate_text!(value, field, limit)
+    unless value.is_a?(String) && value.valid_encoding? && value.bytesize.between?(1, limit) && !value.strip.empty?
+      raise ArgumentError, "invalid Tuix #{field}"
+    end
+    value
+  end
+
+  # Only pass trusted, authenticated host identities, with verified emails.
+  def self.identity(user, secret: configuration.secret)
+    return nil if user.nil?
+    raise ArgumentError, "Tuix user must be a hash with :id and :name" unless user.is_a?(Hash)
+    id = user[:id].is_a?(Integer) ? user[:id].to_s : user[:id]
+    validate_text!(id, :id, 200)
+    validate_text!(user[:name], :name, 200)
+    unless secret.is_a?(String) && secret.bytesize >= 32
+      raise ArgumentError, "Tuix project secret must be at least 32 bytes"
+    end
+    email = user[:email]
+    unless email.nil?
+      validate_text!(email, :email, 254)
+      email = email.strip.downcase
+      raise ArgumentError, "invalid Tuix email" unless email.match?(/\A[^\s@]+@[^\s@]+\.[^\s@]+\z/)
+    end
+    message = email ? "#{id}\n#{email}" : id
+    result = { id: id, name: user[:name], hash: OpenSSL::HMAC.hexdigest("SHA256", secret, message) }
+    result[:email] = email if email
+    result
+  end
+
+  def self.api_origin(value)
+    validate_text!(value, :api, 2048)
+    url = URI.parse(value)
+    unless url.is_a?(URI::HTTP) && url.host && !url.host.empty? && !url.userinfo && !url.query && !url.fragment &&
+        ["", "/"].include?(url.path) && url.port.between?(1, 65_535) &&
+        (url.scheme == "https" || %w[localhost 127.0.0.1].include?(url.host))
+      raise ArgumentError, "Tuix API must be an HTTPS origin (HTTP is allowed on localhost)"
+    end
+    value.delete_suffix("/")
+  rescue URI::InvalidURIError
+    raise ArgumentError, "invalid Tuix API origin"
+  end
+
+  def self.payload(user, nonce: nil)
+    config = configuration
+    return nil if user.nil? || [config.project, config.secret, config.api].any? { |value| value.nil? || value == "" }
+    validate_text!(config.project, :project, 128)
+    unless config.environment.is_a?(String) && config.environment.match?(/\A[a-z][a-z0-9_-]{0,39}\z/)
+      raise ArgumentError, "invalid Tuix environment"
+    end
+    options = { project: config.project, api: api_origin(config.api), environment: config.environment, nonce: nonce }
+    options[:release] = validate_text!(config.release, :release, 200) if config.release
+    { options: options, user: identity(user), delivery: "hosted" }
+  end
+end
+
+require_relative "tuix_rails/railtie" if defined?(Rails::Railtie)

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification
+name: tuix_rails
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Tuix
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
+- !ruby/object:Gem::Dependency
+  name: actionview
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
+description: Server-signed Tuix identities, hosted widget delivery and Turbo lifecycle
+  integration for Rails applications.
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- assets/bootstrap.js
+- lib/generators/tuix/install_generator.rb
+- lib/tuix_rails.rb
+- lib/tuix_rails/assets.rb
+- lib/tuix_rails/helper.rb
+- lib/tuix_rails/railtie.rb
+- lib/tuix_rails/version.rb
+homepage: https://tuix.app
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://tuix.app
+  source_code_uri: https://github.com/tuix-app/tuix/tree/main/packages/rails
+  documentation_uri: https://github.com/tuix-app/tuix/tree/main/packages/rails#readme
+  bug_tracker_uri: https://github.com/tuix-app/tuix/issues
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Signed Tuix feedback widget integration for Rails
+test_files: []