ideasbugs 1.0.1 → 1.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA256:
3
- metadata.gz: 76f8be375e72b7a33a5f0f5b6bc0fc895ced476aeb3b5325a950fa0a7bd01475
4
- data.tar.gz: 565e8e8d07ea9c2604748e88774ebe67bec1473648110b97f0c797911b72127d
3
+ metadata.gz: f1e288c1f22144db48200a796fddc805d6a7e420d5f9b1c7a88cd74be51b800c
4
+ data.tar.gz: beb0741c4e1c81dd46bd91f776525a3cabdac8028927e99ecb3f650129310127
5
5
  SHA512:
6
- metadata.gz: a9623c31745f085489bf222390b964324391f63396d87f3cfa32714a4cbc29180a2703350571840006cc81121e92541a06224a7d831cdb407e7027f6afa9d56a
7
- data.tar.gz: eb8cade7b5bed11612632d95e83cc828c831351721df1dfbb43ea0c54f11dbe7d6ee5f24b79c123f6b6bfcee215a1d3d2140fbd9a3b9c17fb1bdaab883dab58e
6
+ metadata.gz: 7e65c2eaa8171bdb2c67c5737503c353f2c90d755ce17334b0c18b2670e1cf77e04f90dd8c753f46417c0e910901219b2fde794ea4b5a4bcc49e0ff666905b31
7
+ data.tar.gz: d5c9b2d8960368ef45cb1ecdf0d3c24a91c951fef728ad6067bea3ffac0e66a1443f196040e434510723c9103ec4d0b189847a3b38f89cbb484f020a726b72a1
data/CHANGELOG.md CHANGED
@@ -2,6 +2,34 @@
2
2
 
3
3
  ## [Unreleased]
4
4
 
5
+ ## [1.2.0] - 2026-11-09
6
+
7
+ - Add `Ideasbugs::Feedback.submit(attributes, author:, tenant:, user_agent:,
8
+ screenshots:)`, the widget's submission rules as one call: page URL privacy
9
+ filtering, author attribution, screenshot limits and the `on_submit` hook.
10
+ A host exposing feedback through its own API calls it instead of
11
+ re-implementing them. Only `kind`, `section`, `message` and `page_url` are
12
+ taken from attributes. The widget endpoint now uses the same method; its
13
+ responses and error messages are unchanged. No migration or initializer
14
+ change.
15
+
16
+ ## [1.1.0] - 2026-10-18
17
+
18
+ - Add Rails edge CI and experimental Ruby 4.0+ Ractor request support. The host
19
+ must opt into `Rails.application.ractorize!` and use the upstream Rack/I18n
20
+ dependencies documented in `docs/ractors.md`.
21
+ - Exercise actual multipart uploads and private downloads in worker Ractors
22
+ when Active Storage is installed, alongside the optional-dependency-free host.
23
+ - Prepare immutable widget assets and a frozen configuration snapshot at
24
+ Ractorization. Callbacks still run for each request, with isolated captures;
25
+ callbacks that capture mutable state fail at boot with the setting name.
26
+ Normal Rails boots retain mutable configuration and lazy asset loading.
27
+ - Bridge framework operations that are not yet Ractor safe (mounted URL
28
+ generation, digests/key derivation and attribute factories) to the main
29
+ Ractor. This adds dispatch overhead in Ractor mode; it is compatibility
30
+ support, not a claim of improved throughput. Existing Rails 7.1–8.1 installs
31
+ need no migration or initializer changes.
32
+
5
33
  ## [1.0.1] - 2026-08-11
6
34
 
7
35
  - **Screenshot responses now stream privately through the gated engine route.**
data/README.md CHANGED
@@ -386,3 +386,9 @@ touch your own CSS — and migrations that follow your app's `primary_key_type`.
386
386
 
387
387
  MIT. Formerly published as `feedback_engine` — see the
388
388
  [CHANGELOG](CHANGELOG.md) for rename notes.
389
+
390
+ ## Rails edge and Ractors
391
+
392
+ Rails edge is tested alongside Rails 7.1–8.1. Experimental Ruby 4.0+ Ractor hosting
393
+ requires additional upstream dependencies and freezes configuration at startup.
394
+ See [the Ractor hosting guide](docs/ractors.md) for callbacks, requirements and checks.
data/Rakefile CHANGED
@@ -5,7 +5,7 @@ require 'rake/testtask'
5
5
 
6
6
  Rake::TestTask.new(:test) do |t|
7
7
  t.libs << 'test'
8
- t.test_files = FileList['test/**/*_test.rb'].exclude('test/system/**/*')
8
+ t.test_files = FileList['test/**/*_test.rb'].exclude('test/system/**/*', 'test/ractor/**/*')
9
9
  end
10
10
 
11
11
  namespace :test do
@@ -17,3 +17,11 @@ namespace :test do
17
17
  end
18
18
 
19
19
  task default: :test
20
+
21
+ namespace :test do
22
+ desc 'Run isolated configuration and Rails edge Ractor request tests (Ruby 4.0+)'
23
+ task :ractor do
24
+ ruby '-Itest', 'test/ractor/configuration_test.rb'
25
+ ruby '-Itest', 'test/ractor/requests_test.rb'
26
+ end
27
+ end
@@ -1,7 +1,5 @@
1
1
  # frozen_string_literal: true
2
2
 
3
- require 'uri'
4
-
5
3
  module Ideasbugs
6
4
  # Who is asking, which tenant they are in, and the gates that answer both.
7
5
  #
@@ -49,23 +47,5 @@ module Ideasbugs
49
47
  def tenant_scope
50
48
  Feedback.for_tenant(current_tenant)
51
49
  end
52
-
53
- # Browser URLs can carry password-reset tokens, signed ids, and campaign
54
- # details in their query or fragment. Store only a bounded HTTP(S) location
55
- # without credentials before it reaches the feedback table.
56
- def clean_page_url(value)
57
- raw = value.to_s
58
- return if raw.blank? || raw.length > 2_048
59
-
60
- uri = URI.parse(raw)
61
- return unless %w[http https].include?(uri.scheme&.downcase)
62
- return if uri.host.blank? || uri.userinfo.present?
63
-
64
- uri.query = nil
65
- uri.fragment = nil
66
- uri.to_s.first(255)
67
- rescue URI::InvalidURIError
68
- nil
69
- end
70
50
  end
71
51
  end
@@ -16,23 +16,21 @@ module Ideasbugs
16
16
  # this is a no-op. Tune or disable via config.rate_limit — read once at
17
17
  # boot, after the host's initializer.
18
18
  if respond_to?(:rate_limit) && Ideasbugs.config.rate_limit
19
- rate_limit(**Ideasbugs.config.rate_limit,
19
+ Ideasbugs::RactorSupport.rate_limit(self, **Ideasbugs.config.rate_limit,
20
20
  only: :create,
21
21
  with: -> { render json: { errors: [t_error(:error_rate_limited)] }, status: :too_many_requests })
22
22
  end
23
23
 
24
24
  def create
25
- feedback = Feedback.new(feedback_params)
26
- feedback.page_url = clean_page_url(feedback.page_url)
27
- feedback.user_agent = request.user_agent
28
- feedback.tenant = current_tenant
29
- attribute_author(feedback)
30
-
31
- error = attach_screenshots(feedback)
32
- return render json: { errors: [error] }, status: :unprocessable_entity if error
33
-
34
- if feedback.save
35
- notify_host(feedback)
25
+ feedback = Feedback.submit(
26
+ params.require(:feedback).permit(*Feedback::SUBMITTED_ATTRIBUTES),
27
+ author: current_author,
28
+ tenant: current_tenant,
29
+ user_agent: request.user_agent,
30
+ screenshots: params.dig(:feedback, :screenshots)
31
+ )
32
+
33
+ if feedback.persisted?
36
34
  head :created
37
35
  else
38
36
  render json: { errors: feedback.errors.full_messages }, status: :unprocessable_entity
@@ -41,61 +39,8 @@ module Ideasbugs
41
39
 
42
40
  private
43
41
 
44
- # The host's hook must never turn a saved submission into a 500 — the
45
- # feedback is in the database; notification failures are the host's logs'
46
- # problem.
47
- def notify_host(feedback)
48
- Ideasbugs.config.on_submit.call(feedback)
49
- rescue StandardError => e
50
- Rails.logger.error("ideasbugs: on_submit hook raised #{e.class}: #{e.message}")
51
- end
52
-
53
- def feedback_params
54
- params.require(:feedback).permit(:kind, :section, :message, :page_url)
55
- end
56
-
57
- def attribute_author(feedback)
58
- author = current_author
59
- return unless author
60
-
61
- feedback.author_id = author.id.to_s if author.respond_to?(:id)
62
- feedback.author_label = Ideasbugs.config.author_label.call(author)
63
- end
64
-
65
- # Validates and attaches uploads. Returns an error message, or nil when
66
- # everything (including "no screenshots at all") is fine.
67
- def attach_screenshots(feedback)
68
- files = Array(params.dig(:feedback, :screenshots)).reject(&:blank?)
69
- return nil if files.empty?
70
- return t_error(:error_save) unless Ideasbugs.config.screenshots_enabled?
71
- return t_error(:error_too_many, count: Ideasbugs.config.max_screenshots) if too_many?(files)
72
- return t_error(:error_too_large, size: max_size_mb) if files.any? { |f| f.size > max_size }
73
- return t_error(:error_save) unless files.all? { |f| f.content_type.to_s.start_with?('image/') }
74
-
75
- feedback.screenshots.attach(files)
76
- nil
77
- end
78
-
79
- def too_many?(files)
80
- files.size > Ideasbugs.config.max_screenshots
81
- end
82
-
83
- def max_size_mb
84
- max_size / (1024 * 1024)
85
- end
86
-
87
- def max_size
88
- Ideasbugs.config.max_screenshot_size
89
- end
90
-
91
- def t_error(key, **args)
92
- defaults = {
93
- error_save: 'Could not send feedback. Please try again.',
94
- error_too_many: 'Too many screenshots (max %{count}).',
95
- error_too_large: 'A screenshot is too large (max %{size} MB).',
96
- error_rate_limited: 'Too many submissions. Please wait a moment and try again.'
97
- }
98
- I18n.t(key, scope: :ideasbugs, default: defaults[key], **args)
42
+ def t_error(key, **)
43
+ Feedback.submission_error(key, **)
99
44
  end
100
45
  end
101
46
  end
@@ -1,5 +1,7 @@
1
1
  # frozen_string_literal: true
2
2
 
3
+ require 'uri'
4
+
3
5
  module Ideasbugs
4
6
  # One piece of user feedback. Author attribution is optional and stored as
5
7
  # loose fields (no foreign key to the host's user table) so the model is
@@ -30,11 +32,104 @@ module Ideasbugs
30
32
 
31
33
  STATUSES.each do |status|
32
34
  scope status, -> { where(status:) }
33
- define_method(:"#{status}?") { self.status == status }
34
35
  end
35
36
 
37
+ SUBMITTED_ATTRIBUTES = %i[kind section message page_url].freeze
38
+
39
+ # Files feedback the way the widget does: privacy-filtered page URL, author
40
+ # attribution, screenshot limits, then the host's on_submit hook. A host
41
+ # with its own API calls this rather than re-implementing those rules.
42
+ # Returns the feedback; check persisted? and errors.
43
+ def self.submit(attributes, author: nil, tenant: nil, user_agent: nil, screenshots: nil)
44
+ feedback = new(attributes.to_h.symbolize_keys.slice(*SUBMITTED_ATTRIBUTES))
45
+ feedback.page_url = clean_page_url(feedback.page_url)
46
+ feedback.user_agent = user_agent
47
+ feedback.tenant = tenant.presence&.to_s
48
+ feedback.attribute_to(author)
49
+
50
+ if (error = feedback.attach_screenshots(Array(screenshots).compact_blank))
51
+ feedback.errors.add(:base, error)
52
+ elsif feedback.save
53
+ feedback.notify_host
54
+ end
55
+ feedback
56
+ end
57
+
58
+ # Browser URLs can carry password-reset tokens, signed ids, and campaign
59
+ # details in their query or fragment. Store only a bounded HTTP(S) location
60
+ # without credentials before it reaches the feedback table.
61
+ def self.clean_page_url(value)
62
+ raw = value.to_s
63
+ return if raw.blank? || raw.length > 2_048
64
+
65
+ uri = URI.parse(raw)
66
+ return unless %w[http https].include?(uri.scheme&.downcase)
67
+ return if uri.host.blank? || uri.userinfo.present?
68
+
69
+ uri.query = nil
70
+ uri.fragment = nil
71
+ uri.to_s.first(255)
72
+ rescue URI::InvalidURIError
73
+ nil
74
+ end
75
+
76
+ def self.submission_error(key, **args)
77
+ defaults = {
78
+ error_save: 'Could not send feedback. Please try again.',
79
+ error_too_many: 'Too many screenshots (max %{count}).',
80
+ error_too_large: 'A screenshot is too large (max %{size} MB).',
81
+ error_rate_limited: 'Too many submissions. Please wait a moment and try again.'
82
+ }
83
+ I18n.t(key, scope: :ideasbugs, default: defaults[key], **args)
84
+ end
85
+
86
+ def open? = status == 'open'
87
+ def in_review? = status == 'in_review'
88
+ def resolved? = status == 'resolved'
89
+
36
90
  def screenshots?
37
91
  respond_to?(:screenshots) && screenshots.attached?
38
92
  end
93
+
94
+ def attribute_to(author)
95
+ return unless author
96
+
97
+ self.author_id = author.id.to_s if author.respond_to?(:id)
98
+ self.author_label = Ideasbugs.config.author_label.call(author)
99
+ end
100
+
101
+ # Attaches uploads, or returns the error that rejects them. No screenshots
102
+ # at all is fine.
103
+ def attach_screenshots(files)
104
+ return if files.empty?
105
+
106
+ key, args = screenshot_error(files)
107
+ return self.class.submission_error(key, **args.to_h) if key
108
+
109
+ screenshots.attach(files)
110
+ nil
111
+ end
112
+
113
+ # The host's hook must never turn a saved submission into a failure: the
114
+ # feedback is in the database; notification failures are the host's logs'
115
+ # problem.
116
+ def notify_host
117
+ Ideasbugs.config.on_submit.call(self)
118
+ rescue StandardError => e
119
+ Rails.logger.error("ideasbugs: on_submit hook raised #{e.class}: #{e.message}")
120
+ end
121
+
122
+ private
123
+
124
+ def screenshot_error(files)
125
+ config = Ideasbugs.config
126
+ return [:error_save] unless config.screenshots_enabled?
127
+ return [:error_too_many, { count: config.max_screenshots }] if files.size > config.max_screenshots
128
+
129
+ max_size = config.max_screenshot_size
130
+ return [:error_too_large, { size: max_size / (1024 * 1024) }] if files.any? { |f| f.size > max_size }
131
+
132
+ [:error_save] unless files.all? { |f| f.content_type.to_s.start_with?('image/') }
133
+ end
39
134
  end
40
135
  end
data/docs/ractors.md ADDED
@@ -0,0 +1,123 @@
1
+ # Rails edge and experimental Ractor hosting
2
+
3
+ The regular CI matrix covers Rails 7.1, 7.2, 8.0 and 8.1. A required Rails
4
+ edge job runs the same suite against `rails/rails` main. A separate job boots
5
+ an eager-loaded host, calls `Rails.application.ractorize!`, and sends real
6
+ Rack requests through the mounted engine in non-main Ractors, including
7
+ simultaneous requests. The Ractor checks run in separate processes because
8
+ Ractorization freezes Rails; they never freeze the ordinary test application.
9
+
10
+ ## Host prerequisites
11
+
12
+ Ractor hosting currently requires Ruby 4.0+, Rails main, Rack main's
13
+ `rack/ractorize`, and the unreleased [I18n Ractor support](https://github.com/ruby-i18n/i18n/pull/741).
14
+ `gemfiles/rails_ractor.gemfile` records the exact I18n revision tested. These
15
+ are development/test dependencies, not new runtime dependencies for released
16
+ Rails. The gem's supported dependency range remains Rails >= 7.1 and < 9.
17
+
18
+ For a host experimenting with Ractor hosting, the tested upstream overrides are:
19
+
20
+ ```ruby
21
+ gem "rails", github: "rails/rails", branch: "main"
22
+ gem "rack", github: "rack/rack", branch: "main"
23
+ gem "i18n", github: "Shopify/i18n", ref: "58aa1dcd3e04c34831e1c2ec06c83391559c7c91"
24
+ ```
25
+
26
+ Follow Rails' own Ractor hosting requirements: disable reloading, eager-load
27
+ application code, use a shareable logger/cache and a Ractor-compatible job
28
+ adapter. Before application classes load, enable Rails' callback isolation:
29
+
30
+ ```ruby
31
+ require "active_support/ractors"
32
+ ActiveSupport::Ractors.unshareable_proc_action = :raise
33
+ ```
34
+
35
+ Our isolated fixture uses `ActiveSupport::Ractors::Logger`, a null
36
+ cache, and (where jobs are loaded) `:inline`. Its separate shared counter proves
37
+ that public submission limits remain effective across worker Ractors. The
38
+ ordinary dummy application's `:test` job adapter is unchanged.
39
+
40
+ The engine prepares itself automatically on `before_ractorize`; ordinary Rails
41
+ boots do not freeze its configuration or load the experimental I18n extension.
42
+ An unavailable I18n Ractor extension produces a startup error explaining the
43
+ prerequisite. Rails edge and Ractor hosting remain experimental: this is not a
44
+ promise that every third-party host middleware, database driver, storage
45
+ service, mail adapter or Action Cable adapter is Ractor safe.
46
+
47
+ ## Configuration and callbacks
48
+
49
+ Finish configuring Ideasbugs before calling `ractorize!`. The engine publishes
50
+ a frozen copy of the configuration and warms/freezes widget JS, CSS and content
51
+ fingerprints. Changes after Ractorization require a process restart. Arrays and
52
+ hashes supplied by the host are copied before freezing.
53
+
54
+ Callbacks are isolated with Ruby's `Ractor.shareable_lambda` or
55
+ `Ractor.shareable_proc`, preserving lambda/proc arity. They continue to receive
56
+ the same request, user, record or event arguments and run on each request.
57
+ Isolated callbacks use arguments and constants; their implicit initializer
58
+ `self` becomes nil, following Rails' isolated callback convention.
59
+
60
+ ```ruby
61
+ Ideasbugs.configure do |config|
62
+ config.enabled = ->(request) { request.get_header("HTTP_X_WIDGET") != "off" }
63
+ end
64
+ ```
65
+
66
+ Immutable captured values must already be shareable:
67
+
68
+ ```ruby
69
+ expected_host = "app.example.com".freeze
70
+ Ideasbugs.configure do |config|
71
+ config.enabled = ->(request) { request.host == expected_host }
72
+ end
73
+ ```
74
+
75
+ Mutable captures (an array collecting notifications, an unfrozen captured
76
+ string, or reassigned outer locals) cannot be shared. The engine fails at
77
+ startup with `Ideasbugs.config.<setting>` in the error rather than failing on
78
+ a visitor's request. Use request-local state and external persistence for
79
+ side effects. A pre-isolated callback made with an explicit shareable `self:`
80
+ keeps that receiver. Stateful callable objects must be copyable/shareable;
81
+ custom objects remain subject to Ruby's Ractor rules.
82
+
83
+ ## Scope and cost
84
+
85
+ Some Rails main paths are still being converted to Ractors. The engine warms
86
+ model attributes and controller names, prepares ETag callbacks, and supplies
87
+ narrow bridges for mounted URL generation, cache freshness, digest/key
88
+ operations, GlobalID URI decoding and boot-time attribute decorators. Those bridges preserve the
89
+ original operation on the main Ractor; requests, authorization callbacks,
90
+ rendering and persistence orchestration execute in their worker Ractors.
91
+ Adapter name quoting delegates to its original implementation on the main Ractor,
92
+ which preserves escaping and avoids process-global mutable caches in workers.
93
+ Disk-backed uploads use Ractor-local storage clients and plain temporary files
94
+ with explicit cleanup, because Tempfile's generated delegation methods cannot
95
+ be called from another Ractor. MIME registrations must finish before
96
+ Ractorization, when Marcel's MIME tables become immutable. Eager model schema
97
+ preparation adds startup database work.
98
+ The bridges are internal compatibility code, add coordination overhead, and
99
+ must be reviewed as upstream Rails evolves. No throughput improvement is claimed.
100
+
101
+ ## Run the checks
102
+
103
+ Use the Ruby configured in `mise.toml`, never macOS's system Ruby.
104
+
105
+ ```sh
106
+ BUNDLE_GEMFILE=gemfiles/rails_edge.gemfile bundle install
107
+ BUNDLE_GEMFILE=gemfiles/rails_edge.gemfile bundle exec rake test
108
+ BUNDLE_GEMFILE=gemfiles/rails_ractor.gemfile bundle install
109
+ BUNDLE_GEMFILE=gemfiles/rails_ractor.gemfile bundle exec rake test:ractor
110
+ ```
111
+
112
+ The request fixture creates and removes its own temporary database and host;
113
+ it does not reuse or freeze `test/dummy`. The shared schema lives in
114
+ `test/support/schema.rb` so the ordinary and Ractor suites exercise the same
115
+ record shape. Successful checks establish the tested SQLite host and explicit
116
+ request paths, not all combinations of host integrations.
117
+
118
+ The media job also runs with `RACTOR_MEDIA=1`, exercising private disk-backed
119
+ Active Storage downloads through the engine's authorization gate. Storage
120
+ services are initialized per Ractor, and streamed responses use a thread local
121
+ to that Ractor. Livechat additionally runs with `RACTOR_CABLE=1`, checking the
122
+ signed stream token and broadcasts delegated to the main Action Cable server.
123
+ Other storage services and production Cable adapters need host-specific QA.
Binary file
Binary file
Binary file
@@ -2,8 +2,19 @@
2
2
 
3
3
  module Ideasbugs
4
4
  class Engine < ::Rails::Engine
5
+ initializer 'ideasbugs.ractor_middleware' do |app|
6
+ app.middleware.insert_before 0, RactorSupport::Middleware
7
+ end
8
+
5
9
  isolate_namespace Ideasbugs
6
10
 
11
+ initializer 'ideasbugs.ractorize', before: 'action_controller.ractorize' do
12
+ if Rails::Application.method_defined?(:ractorize!)
13
+ Engine.routes.singleton_class.prepend(RactorSupport::MountedRoutes)
14
+ end
15
+ ActiveSupport.on_load(:before_ractorize) { Ideasbugs::RactorSupport.prepare! }
16
+ end
17
+
7
18
  rake_tasks do
8
19
  load File.expand_path('../tasks/ideasbugs_tasks.rake', __dir__)
9
20
  end
@@ -22,7 +22,17 @@ module Ideasbugs
22
22
  def has_feedback(as: :feedback, key: nil) # rubocop:disable Naming/PredicatePrefix
23
23
  resolver = key || ->(record) { record.to_gid.to_s }
24
24
 
25
- define_method(as) { Ideasbugs::Feedback.for_tenant(resolver.call(self)) }
25
+ class_attribute :_ideasbugs_feedback_resolvers, instance_accessor: false, default: {} unless
26
+ respond_to?(:_ideasbugs_feedback_resolvers)
27
+ feedback_name = as.to_sym
28
+ declaring_model = self
29
+ self._ideasbugs_feedback_resolvers = _ideasbugs_feedback_resolvers.merge(feedback_name => resolver)
30
+ getter = proc do
31
+ key_resolver = declaring_model._ideasbugs_feedback_resolvers.fetch(feedback_name)
32
+ Ideasbugs::Feedback.for_tenant(key_resolver.call(self))
33
+ end
34
+ getter = Ractor.shareable_proc(&getter) if defined?(Ractor.shareable_proc)
35
+ define_method(as, &getter)
26
36
  end
27
37
  end
28
38
  end
@@ -0,0 +1,521 @@
1
+ # frozen_string_literal: true
2
+
3
+ module Ideasbugs
4
+ # Used only by Rails' opt-in before_ractorize hook. Normal Rails boots keep
5
+ # mutable configuration and lazy assets, including on older Ruby versions.
6
+ module RactorSupport
7
+ # Small bridges for framework paths that Rails main does not prepare yet.
8
+ # They are installed only when the host explicitly calls ractorize!.
9
+ # Rails' built-in JSON renderer is still defined from an unisolated Proc.
10
+ # Keep its JSON/JSONP and escaping behavior in a regular Ruby method.
11
+ module JsonRendering
12
+ def _render_with_renderer_json(json, options)
13
+ json_options = options.except(:callback, :content_type, :status)
14
+ json_options[:escape] ||= false if !self.class.escape_json_responses? && options[:callback].blank?
15
+ json = json.to_json(json_options) unless json.is_a?(String)
16
+ if options[:callback].present?
17
+ self.content_type = :js if media_type.nil? || media_type == Mime[:json]
18
+ "/**/#{options[:callback]}(#{json})"
19
+ else
20
+ self.content_type = :json if media_type.nil?
21
+ json
22
+ end
23
+ end
24
+ end
25
+
26
+ module DependencyInterlock
27
+ def interlock
28
+ return super if Ractor.main?
29
+
30
+ Ractor[:engine_dependency_interlock] ||= ActiveSupport::Dependencies::Interlock.new
31
+ end
32
+ end
33
+
34
+ module LiveThreads
35
+ private
36
+
37
+ def new_controller_thread
38
+ return super if Ractor.main?
39
+
40
+ Thread.new do
41
+ Thread.current.abort_on_exception = true
42
+ yield
43
+ end
44
+ end
45
+ end
46
+
47
+ module UniquenessCoverage
48
+ private
49
+
50
+ def covered_by_unique_index?(klass, record, attribute, scope)
51
+ return super unless frozen?
52
+
53
+ copies = Ractor[:engine_uniqueness_validators] ||= {}
54
+ copy = copies[[self, klass]] ||= dup
55
+ copy.send(:covered_by_unique_index?, klass, record, attribute, scope)
56
+ end
57
+ end
58
+
59
+ # GlobalID calls CGI.unescape without an encoding, whose default reads a
60
+ # process-wide class variable. Preserve CGI's configured default on main.
61
+ module UriUnescaping
62
+ def unescape(string, *arguments)
63
+ return super if Ractor.main?
64
+
65
+ shared_arguments = Ractor.make_shareable([string, *arguments], copy: true)
66
+ ActiveSupport::Ractors.on_main(self) { unescape(*shared_arguments) }
67
+ end
68
+ end
69
+
70
+ module CacheFreshness
71
+ def strict_freshness
72
+ return super if Ractor.main?
73
+
74
+ ActiveSupport::Ractors.on_main(self) { strict_freshness }
75
+ end
76
+ end
77
+
78
+ # Attribute decorators (including Rails enums and serialized attributes)
79
+ # are boot-time factories. Keep their original receivers and captures on
80
+ # the main Ractor, rather than changing the semantics of Rails' closures.
81
+ class Decorator
82
+ def initialize(callback)
83
+ @key = RactorSupport.register_decorator(callback)
84
+ freeze
85
+ end
86
+
87
+ def call(*arguments)
88
+ return RactorSupport.call_decorator(@key, arguments) if Ractor.main?
89
+
90
+ shared_arguments = Ractor.make_shareable(arguments, copy: true)
91
+ ActiveSupport::Ractors.on_main(self) { RactorSupport.call_decorator(@key, shared_arguments) }
92
+ end
93
+ end
94
+
95
+ def self.register_decorator(callback)
96
+ @decorators ||= []
97
+ @decorators << callback
98
+ @decorators.length - 1
99
+ end
100
+
101
+ def self.call_decorator(key, arguments)
102
+ @decorators.fetch(key).call(*arguments)
103
+ end
104
+
105
+ def self.prepare_attributes(model)
106
+ prepare_attributes(model.superclass) if model.superclass.respond_to?(:pending_attribute_modifications, true)
107
+ model.send(:pending_attribute_modifications)&.each do |modification|
108
+ next unless modification.respond_to?(:decorator) && modification.decorator.is_a?(Proc)
109
+
110
+ modification.decorator = Decorator.new(modification.decorator)
111
+ end
112
+ end
113
+
114
+ module AdapterQuoting
115
+ def quote_column_name(name)
116
+ return super if Ractor.main?
117
+
118
+ shared_name = Ractor.make_shareable(name, copy: true)
119
+ ActiveSupport::Ractors.on_main(self) { quote_column_name(shared_name) }
120
+ end
121
+
122
+ def quote_table_name(name)
123
+ return super if Ractor.main?
124
+
125
+ shared_name = Ractor.make_shareable(name, copy: true)
126
+ ActiveSupport::Ractors.on_main(self) { quote_table_name(shared_name) }
127
+ end
128
+ end
129
+
130
+ # Route arguments can contain records with native Set caches. Only their
131
+ # to_param value is needed to generate a mount prefix; keep the caller's
132
+ # original record objects in the options passed to the actual route.
133
+ def self.routing_snapshot(value)
134
+ return value if Ractor.shareable?(value)
135
+
136
+ copy = case value
137
+ when ActiveRecord::Base then value.to_param
138
+ when Hash then value.to_h { |key, item| [routing_snapshot(key), routing_snapshot(item)] }
139
+ when Array then value.map { |item| routing_snapshot(item) }
140
+ when Set then Set.new(value.map { |item| routing_snapshot(item) })
141
+ else return Ractor.make_shareable(value, copy: true)
142
+ end
143
+ Ractor.make_shareable(copy)
144
+ end
145
+
146
+ module MountedRoutes
147
+ def find_script_name(options)
148
+ return super unless defined?(Ractor.shareable_proc) && !Ractor.main?
149
+
150
+ shared_options = RactorSupport.routing_snapshot(options)
151
+ prefix, updated = ActiveSupport::Ractors.on_main(self) do
152
+ local_options = shared_options.dup
153
+ [find_script_name(local_options), local_options]
154
+ end
155
+ (shared_options.keys - updated.keys).each { |key| options.delete(key) }
156
+ updated.each do |key, value|
157
+ options[key] = value unless shared_options.key?(key) && shared_options[key] == value
158
+ end
159
+ prefix
160
+ end
161
+ end
162
+
163
+ module Digesting
164
+ def hexdigest(value)
165
+ return super if Ractor.main?
166
+
167
+ shared_value = Ractor.make_shareable(value, copy: true)
168
+ ActiveSupport::Ractors.on_main(self) { hexdigest(shared_value) }
169
+ end
170
+ end
171
+
172
+ module KeyGeneration
173
+ def generate_key(salt, key_size = 64)
174
+ return super if Ractor.main?
175
+
176
+ shared_salt = Ractor.make_shareable(salt, copy: true)
177
+ ActiveSupport::Ractors.on_main(self) { generate_key(shared_salt, key_size) }
178
+ end
179
+ end
180
+
181
+ module UploadCleanup
182
+ def open
183
+ reopen(path, 'rb+')
184
+ self
185
+ end
186
+
187
+ # Tempfile#close takes a positional unlink flag.
188
+ def close(unlink_now = false) # rubocop:disable Style/OptionalBooleanParameter
189
+ super() unless closed?
190
+ unlink if unlink_now
191
+ end
192
+
193
+ def unlink
194
+ File.unlink(path)
195
+ rescue Errno::ENOENT
196
+ nil
197
+ end
198
+
199
+ def close!
200
+ close(true)
201
+ end
202
+ end
203
+
204
+ def self.upload_tempfile(filename, _content_type)
205
+ extension = File.extname(filename.gsub("\0", '%00'))[0, 129]
206
+ Tempfile.create(['RackMultipart', extension]).extend(UploadCleanup)
207
+ end
208
+
209
+ class Middleware
210
+ def initialize(app)
211
+ @app = app
212
+ end
213
+
214
+ def call(env)
215
+ if (fallbacks = RactorSupport.fallbacks)
216
+ Fiber[:i18n_fallbacks] ||= fallbacks
217
+ env['rack.multipart.tempfile_factory'] ||= RactorSupport.method(:upload_tempfile) unless Ractor.main?
218
+ end
219
+ @app.call(env)
220
+ end
221
+ end
222
+
223
+ def self.fallbacks
224
+ @fallbacks
225
+ end
226
+
227
+ module StorageMetadata
228
+ def analyzed = read_store_attribute(:metadata, :analyzed)
229
+ def identified = read_store_attribute(:metadata, :identified)
230
+ def composed = read_store_attribute(:metadata, :composed)
231
+
232
+ def analyzed=(value)
233
+ write_store_attribute(:metadata, :analyzed, value)
234
+ end
235
+
236
+ def identified=(value)
237
+ write_store_attribute(:metadata, :identified, value)
238
+ end
239
+
240
+ def composed=(value)
241
+ write_store_attribute(:metadata, :composed, value)
242
+ end
243
+ end
244
+
245
+ class StorageServices
246
+ def initialize(configurations)
247
+ @configurations = Ractor.make_shareable(configurations, copy: true)
248
+ freeze
249
+ end
250
+
251
+ def fetch(name, &)
252
+ registry = if Ractor.main?
253
+ RactorSupport.storage_registry
254
+ else
255
+ Ractor[:engine_storage_services] ||= ActiveStorage::Service::Registry.new(@configurations)
256
+ end
257
+ registry.fetch(name, &)
258
+ end
259
+ end
260
+
261
+ def self.storage_registry
262
+ @storage_registry
263
+ end
264
+
265
+ module StorageChecksums
266
+ def checksum_implementation(**options)
267
+ implementation = super
268
+ if Ractor.main? || !implementation.respond_to?(:name) || !implementation.name&.start_with?('OpenSSL::Digest::')
269
+ return implementation
270
+ end
271
+
272
+ DigestFactory.new(implementation.name.delete_prefix('OpenSSL::Digest::'))
273
+ end
274
+ end
275
+
276
+ class DigestFactory
277
+ def initialize(algorithm)
278
+ @algorithm = algorithm.freeze
279
+ freeze
280
+ end
281
+
282
+ def new
283
+ OpenSSL::Digest.new(@algorithm)
284
+ end
285
+
286
+ def file(io)
287
+ new.file(io)
288
+ end
289
+
290
+ def base64digest(value)
291
+ new.base64digest(value)
292
+ end
293
+ end
294
+
295
+ def self.prepare_redirects!
296
+ base = ActionController::Base
297
+ readers = Module.new
298
+ %i[raise_on_open_redirects action_on_open_redirect action_on_path_relative_redirect].each do |key|
299
+ source = base.method(key).source_location&.first
300
+ next unless source&.end_with?('/action_controller/metal/redirecting.rb')
301
+
302
+ value = Ractor.make_shareable(base.public_send(key), copy: true)
303
+ readers.define_method(key, Ractor.shareable_proc { Ractor.main? ? super() : value })
304
+ end
305
+ return if readers.instance_methods(false).empty?
306
+
307
+ base.prepend(readers)
308
+ base.singleton_class.prepend(readers)
309
+ end
310
+
311
+ def self.prepare_previewers!
312
+ ActiveStorage.previewers.each do |previewer|
313
+ readers = Module.new
314
+ previewer.methods.grep(/_exists\?\z/).each do |capability|
315
+ method = previewer.method(capability)
316
+ next unless method.arity.zero? && method.source_location&.first&.include?('/active_storage/previewer/')
317
+
318
+ readers.define_method(capability, Ractor.shareable_proc do
319
+ if Ractor.main?
320
+ super()
321
+ else
322
+ ActiveSupport::Ractors.on_main(self) { public_send(capability) }
323
+ end
324
+ end)
325
+ end
326
+ previewer.singleton_class.prepend(readers) unless readers.instance_methods(false).empty?
327
+ end
328
+ end
329
+
330
+ def self.prepare_storage!
331
+ return unless defined?(ActiveStorage::Blob)
332
+
333
+ prepare_previewers!
334
+ ActiveStorage::Blob.prepend(StorageMetadata) unless ActiveStorage::Blob < StorageMetadata
335
+ %i[EXTENSIONS TYPE_EXTS TYPE_ALIASES TYPE_PARENTS ROOT_XML MAGIC].each do |name|
336
+ Ractor.make_shareable(Marcel.const_get(name)) if Marcel.const_defined?(name)
337
+ end
338
+ ActiveStorage::Service.prepend(StorageChecksums) unless ActiveStorage::Service < StorageChecksums
339
+ unless Ractor.shareable?(ActiveStorage::Blob.services)
340
+ @storage_registry = ActiveStorage::Blob.services
341
+ configurations = @storage_registry.instance_variable_get(:@configurations)
342
+ default_name = ActiveStorage::Blob.service.name
343
+ default_reader = Module.new
344
+ default_reader.define_method(:service, Ractor.shareable_proc do
345
+ Ractor.main? ? super() : services.fetch(default_name)
346
+ end)
347
+ ActiveStorage::Blob.singleton_class.prepend(default_reader)
348
+ ActiveStorage::Blob.services = StorageServices.new(configurations)
349
+ end
350
+ settings = ActiveStorage.class_variables.map { |name| name.to_s.delete_prefix('@@').to_sym }
351
+ settings.select! { |key| ActiveStorage.respond_to?(key) }
352
+ snapshot = settings.to_h { |key| [key, ActiveStorage.public_send(key)] }
353
+ checksum = snapshot[:checksum_implementation]
354
+ if checksum.is_a?(Class) && checksum.name&.start_with?('OpenSSL::Digest::')
355
+ snapshot[:checksum_implementation] = DigestFactory.new(checksum.name.delete_prefix('OpenSSL::Digest::'))
356
+ end
357
+ Ractor.make_shareable(snapshot)
358
+ readers = Module.new
359
+ settings.each do |key|
360
+ readers.define_method(key, Ractor.shareable_proc { Ractor.main? ? super() : snapshot.fetch(key) })
361
+ end
362
+ ActiveStorage.singleton_class.prepend(readers)
363
+ end
364
+
365
+ def self.prepare_framework!
366
+ CGI.singleton_class.prepend(UriUnescaping) unless CGI.singleton_class < UriUnescaping
367
+ Ractor.make_shareable(GlobalID.app) if defined?(GlobalID) && GlobalID.respond_to?(:app)
368
+ I18n.available_locales.each { |locale| I18n.transliterate('ractor', locale: locale) }
369
+ require 'i18n/ractorize'
370
+ require 'tempfile'
371
+ prepare_redirects!
372
+ %i[BASE36_ALPHABET BASE58_ALPHABET].each do |name|
373
+ Ractor.make_shareable(SecureRandom.const_get(name)) if SecureRandom.const_defined?(name)
374
+ end
375
+ uniqueness = ActiveRecord::Validations::UniquenessValidator
376
+ uniqueness.prepend(UniquenessCoverage) unless uniqueness < UniquenessCoverage
377
+ dependencies = ActiveSupport::Dependencies.singleton_class
378
+ dependencies.prepend(DependencyInterlock) unless dependencies < DependencyInterlock
379
+ prepare_storage!
380
+ Ractor.make_shareable(ActiveRecord::Associations::AssociationScope::INSTANCE)
381
+ Ractor.make_shareable(ActionDispatch::Http::Cache::Response::SPECIAL_KEYS)
382
+ freshness = ActionDispatch::Http::Cache::Request.singleton_class
383
+ freshness.prepend(CacheFreshness) unless freshness < CacheFreshness
384
+ fallbacks = I18n.fallbacks
385
+ I18n.available_locales.each { |locale| fallbacks[locale] }
386
+ @fallbacks = Ractor.make_shareable(fallbacks)
387
+ ActiveSupport::Digest.singleton_class.prepend(Digesting) unless ActiveSupport::Digest.singleton_class < Digesting
388
+ ActiveSupport::KeyGenerator.prepend(KeyGeneration) unless ActiveSupport::KeyGenerator < KeyGeneration
389
+ ActiveRecord::Base.connection_handler.connection_pool_list.each do |pool|
390
+ adapter = pool.db_config.adapter_class.singleton_class
391
+ adapter.prepend(AdapterQuoting) unless adapter < AdapterQuoting
392
+ end
393
+ rescue LoadError => e
394
+ raise LoadError,
395
+ "Ractor requests need the upstream I18n Ractor support (see gemfiles/rails_ractor.gemfile): #{e.message}"
396
+ end
397
+
398
+ def self.prepare!
399
+ # A cache store can reference the whole middleware stack and freeze
400
+ # other mounted engines before their own hooks run. Warm every engine's
401
+ # request environment before making any of that graph shareable.
402
+ Rails.application.railties.each do |railtie|
403
+ railtie.env_config if railtie.is_a?(Rails::Engine)
404
+ end
405
+ Engine.instance.env_config
406
+ prepare_framework!
407
+ ActiveRecord::Base.descendants.each do |model|
408
+ if model.respond_to?(:_ideasbugs_feedback_resolvers)
409
+ model._ideasbugs_feedback_resolvers = share_options(model._ideasbugs_feedback_resolvers)
410
+ end
411
+ next if model.abstract_class? || !model.table_exists?
412
+
413
+ model.reflect_on_all_associations.each { |reflection| reflection.send(:inverse_name) }
414
+ prepare_attributes(model)
415
+ Ractor.make_shareable(model.defined_enums)
416
+ model.defined_enums.each do |attribute, mapping|
417
+ method_name = attribute.pluralize
418
+ source = model.method(method_name).source_location&.first
419
+ next unless source&.end_with?('/active_record/enum.rb')
420
+
421
+ model.define_singleton_method(method_name, Ractor.shareable_proc { mapping })
422
+ end
423
+ model.define_attribute_methods
424
+ if model.respond_to?(:attachment_reflections)
425
+ model.attachment_reflections.each_value(&:named_variants)
426
+ Ractor.make_shareable(model.attachment_reflections)
427
+ end
428
+ end
429
+ ActionController::Base.descendants.each do |controller|
430
+ next unless controller.name&.start_with?('Ideasbugs::')
431
+
432
+ controller.prepend(LiveThreads) if defined?(ActionController::Live) && controller < ActionController::Live
433
+ renderer_source = controller.instance_method(:_render_with_renderer_json).source_location&.first
434
+ if renderer_source&.end_with?('/action_controller/metal/renderers.rb') && !(controller < JsonRendering)
435
+ controller.prepend(JsonRendering)
436
+ end
437
+ Ractor.make_shareable(controller.controller_name)
438
+ controller.etaggers = controller.etaggers.map { |callback| Ractor.shareable_proc(&callback) }.freeze
439
+ end
440
+ Ideasbugs.instance_variable_set(:@config, configuration(Ideasbugs.config))
441
+ %i[javascript dashboard_javascript dashboard_stylesheet fingerprint
442
+ dashboard_fingerprint dashboard_stylesheet_fingerprint].each do |method|
443
+ next unless Widget.respond_to?(method)
444
+
445
+ Widget.public_send(method)
446
+ end
447
+ ActionController::Base.descendants.each do |controller|
448
+ next unless controller.respond_to?(:ideasbugs_rate_limit_options)
449
+
450
+ options = controller.ideasbugs_rate_limit_options
451
+ controller.ideasbugs_rate_limit_options = share_options(options)
452
+ end
453
+ Widget.instance_variables.each do |variable|
454
+ Widget.instance_variable_set(variable, Ractor.make_shareable(Widget.instance_variable_get(variable)))
455
+ end
456
+ end
457
+
458
+ # Rails edge's rate_limit currently closes over reassigned keyword
459
+ # arguments. A named filter avoids that unshareable closure; the actual
460
+ # counter, cache key and rejection still use Rails' rate_limiting method.
461
+ def self.rate_limit(controller, to:, within:, only:, with:, **options)
462
+ unless Rails::Application.method_defined?(:ractorize!)
463
+ return controller.rate_limit(to: to, within: within, only: only, with: with, **options)
464
+ end
465
+
466
+ controller.class_attribute :ideasbugs_rate_limit_options, instance_accessor: false
467
+ controller.ideasbugs_rate_limit_options = {
468
+ to: to, within: within, by: -> { request.remote_ip }, with: with,
469
+ store: controller.cache_store, name: nil, scope: controller.controller_path
470
+ }.merge(options.slice(:by, :store, :name, :scope))
471
+ controller.ideasbugs_rate_limit_options[:scope] ||= controller.controller_path
472
+ filters = options.except(:by, :store, :name, :scope)
473
+ controller.before_action :ideasbugs_rate_limit, only: only, **filters
474
+ controller.class_eval <<~RUBY, __FILE__, __LINE__ + 1
475
+ private
476
+ def ideasbugs_rate_limit
477
+ rate_limiting(**self.class.ideasbugs_rate_limit_options)
478
+ end
479
+ RUBY
480
+ end
481
+
482
+ def self.share_options(options)
483
+ options.to_h do |key, value|
484
+ value = configuration_value(value) if value.is_a?(Proc)
485
+ [key, Ractor.make_shareable(value)]
486
+ end.freeze
487
+ end
488
+
489
+ def self.configuration_value(value)
490
+ case value
491
+ when Proc
492
+ return value if Ractor.shareable?(value)
493
+
494
+ # Like Rails callbacks, isolated callbacks use arguments and constants,
495
+ # not their initializer's implicit self. Keep lambda/proc arity intact.
496
+ value.lambda? ? Ractor.shareable_lambda(&value) : Ractor.shareable_proc(&value)
497
+ when Hash
498
+ value.to_h { |key, item| [configuration_value(key), configuration_value(item)] }.freeze
499
+ when Array
500
+ value.map { |item| configuration_value(item) }.freeze
501
+ else
502
+ Ractor.make_shareable(value, copy: true)
503
+ end
504
+ end
505
+
506
+ def self.configuration(original)
507
+ prepared = original.dup
508
+ original.instance_variables.each do |variable|
509
+ value = original.instance_variable_get(variable)
510
+ begin
511
+ shared = configuration_value(value)
512
+ prepared.instance_variable_set(variable, shared)
513
+ rescue Ractor::Error, TypeError => e
514
+ setting = variable.to_s.delete_prefix('@')
515
+ raise ArgumentError, "Ideasbugs.config.#{setting} cannot be shared with Ractors: #{e.message}"
516
+ end
517
+ end
518
+ Ractor.make_shareable(prepared)
519
+ end
520
+ end
521
+ end
@@ -1,5 +1,5 @@
1
1
  # frozen_string_literal: true
2
2
 
3
3
  module Ideasbugs
4
- VERSION = '1.0.1'
4
+ VERSION = '1.2.0'
5
5
  end
@@ -12,8 +12,8 @@ module Ideasbugs
12
12
  # that *does* run a pipeline never ingests it either: nothing lands in the
13
13
  # host's asset namespace or precompiled output.
14
14
  module Widget
15
- SOURCE = File.expand_path('widget.js', __dir__)
16
- DASHBOARD_STYLESHEET_SOURCE = File.expand_path('dashboard.css', __dir__)
15
+ SOURCE = File.expand_path('widget.js', __dir__).freeze
16
+ DASHBOARD_STYLESHEET_SOURCE = File.expand_path('dashboard.css', __dir__).freeze
17
17
 
18
18
  # Right-to-left scripts, so the form renders mirrored for those locales.
19
19
  # Matched on the language subtag, so region variants ("ar-EG") count too.
data/lib/ideasbugs.rb CHANGED
@@ -2,6 +2,7 @@
2
2
 
3
3
  require 'ideasbugs/version'
4
4
  require 'ideasbugs/configuration'
5
+ require 'ideasbugs/ractor_support'
5
6
  require 'ideasbugs/widget'
6
7
  require 'ideasbugs/widget_helper'
7
8
  require 'ideasbugs/has_feedback'
metadata CHANGED
@@ -1,7 +1,7 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: ideasbugs
3
3
  version: !ruby/object:Gem::Version
4
- version: 1.0.1
4
+ version: 1.2.0
5
5
  platform: ruby
6
6
  authors:
7
7
  - Yaroslav Shmarov
@@ -87,6 +87,17 @@ files:
87
87
  - config/locales/ideasbugs.vi.yml
88
88
  - config/locales/ideasbugs.zh-CN.yml
89
89
  - config/routes.rb
90
+ - docs/ractors.md
91
+ - docs/screenshots/admin-ui/after-index-mobile.png
92
+ - docs/screenshots/admin-ui/after-index.png
93
+ - docs/screenshots/admin-ui/after-show-mobile.png
94
+ - docs/screenshots/admin-ui/after-show.png
95
+ - docs/screenshots/admin-ui/before-index.png
96
+ - docs/screenshots/admin-ui/before-show.png
97
+ - docs/screenshots/dashboard-dark.png
98
+ - docs/screenshots/dashboard-light.png
99
+ - docs/screenshots/widget-dark.png
100
+ - docs/screenshots/widget-light.png
90
101
  - lib/generators/ideasbugs/install/install_generator.rb
91
102
  - lib/generators/ideasbugs/install/templates/create_ideasbugs_feedbacks.rb.tt
92
103
  - lib/generators/ideasbugs/install/templates/initializer.rb
@@ -98,6 +109,7 @@ files:
98
109
  - lib/ideasbugs/dashboard.css
99
110
  - lib/ideasbugs/engine.rb
100
111
  - lib/ideasbugs/has_feedback.rb
112
+ - lib/ideasbugs/ractor_support.rb
101
113
  - lib/ideasbugs/seeds.rb
102
114
  - lib/ideasbugs/version.rb
103
115
  - lib/ideasbugs/widget.js
@@ -127,7 +139,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
127
139
  - !ruby/object:Gem::Version
128
140
  version: '0'
129
141
  requirements: []
130
- rubygems_version: 4.0.16
142
+ rubygems_version: 4.0.20
131
143
  specification_version: 4
132
144
  summary: 'In-app product feedback collection for Rails: a drop-in widget and a built-in
133
145
  triage dashboard.'