empirical 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3c9b64cdbca71cda53eac79ca46ed80f2e2d0e19901dfa5b7b675c0465c3f4eb
+  data.tar.gz: c8abbdbbdb0cc7dd461e810ee398a8046f259fdc78a1c7b6aa117749c6263f38
+SHA512:
+  metadata.gz: 114a23808cdb5746bfcc791207a80693900c960ef37870f0370c35b3c0bc6d215fff22f59ba9b57516002a31f56d20a76b8982473606da9421dffe9cff585876
+  data.tar.gz: da7ef76d2913b4be14a5dc08ce01a8a4f01fba6d103500eb197c7604cb38dcb12d9f0e23dd24a6d8e9381bd547db6e24bf9876418b42b9e75431d55e1723fbbd

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Joel Drapper
+
+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,175 @@
+# Strict Ivars
+
+If you reference an undefined method, constant or local varaible, Ruby will helpfully raise an error. But reference an undefined _instance_ variable and Ruby just returns `nil`. This can lead to all kinds of bugs — many of which can lay dormant for years before surprising you with an unexpected outage, data breach or data loss event.
+
+Strict Ivars solves this by making Ruby raise a `NameError` any time you read an undefined instance varaible. It’s enabled with two lines of code in your boot process, then it just works in the background and you’ll never have to think about it again. Strict Ivars has no known false-positives or false-negatives.
+
+It’s especially good when used with [Literal](https://literal.fun) and [Phlex](https://www.phlex.fun), though it also works with regular Ruby objects and even ERB templates, which are actually pretty common spots for undefined instance variable reads to hide since that’s the main way of passing data to ERB.
+
+When combined with Literal, you can essentially remove all unexpected `nil`s. Literal validates your inputs and Strict Ivars ensures you’re reading the right instance variables.
+
+> [!NOTE]
+> JRuby and TruffleRuby are not currently supported.
+
+## Setup
+
+Strict Ivars should really be used in apps not libraries. Though you could definitely use it in your library’s test suite to help catch issues in the library code.
+
+Install the gem by adding it to your `Gemfile` and running `bundle install`. You’ll probably want to set it to `require: false` here because you should require it manually at precisely the right moment.
+
+```ruby
+gem "empirical", require: false
+```
+
+Now the gem is installed, you should require and initialize the gem as early as possible in your boot process. Ideally, this should be right after Bootsnap is set up. In Rails, this will be in your `boot.rb` file.
+
+```ruby
+require "empirical"
+```
+
+You can pass an array of globs to `Empirical.init` as `include:` and `exclude:`
+
+```ruby
+Empirical.init(include: ["#{Dir.pwd}/**/*"], exclude: ["#{Dir.pwd}/vendor/**/*"])
+```
+
+This example include everything in the current directory apart from the `./vendor` folder (which is where GitHub Actions installs gems).
+
+If you’re setting this up in Rails, your `boot.rb` file should look something like this.
+
+```ruby
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../Gemfile", __dir__)
+
+require "bundler/setup" # Set up gems listed in the Gemfile.
+require "bootsnap/setup" # Speed up boot time by caching expensive operations.
+
+require "empirical"
+
+Empirical.init(include: ["#{Dir.pwd}/**/*"], exclude: ["#{Dir.pwd}/vendor/**/*"])
+```
+
+If you’re using Bootsnap, you should clear your bootsnap cache by deleting the folder `tmp/cache/bootsnap`.
+
+## How does it work?
+
+When Strict Ivars detects that you are loading code from paths its configured to handle, it quickly looks for instance variable reads and guards them with a `defined?` check.
+
+For example, it will replace this:
+
+```ruby
+def example
+  foo if @bar
+end
+```
+
+...with something like this:
+
+```ruby
+def example
+  foo if (defined?(@bar) ? @bar : raise)
+end
+```
+
+The replacement happens on load, so you never see this in your source code. It’s also always wrapped in parentheses and takes up a single line, so it won’t mess up the line numbers in exceptions.
+
+**Writes:**
+
+Strict Ivars doesn’t apply to writes, since these are considered the authoritative source of the instance variable definitions.
+
+```ruby
+@foo = 1
+```
+
+**Or-writes:**
+
+Or-writes are considered an authoritative definition, not a read.
+
+```ruby
+@foo ||= 1
+```
+
+**And-writes:**
+
+And-writes are considered an authoritative definition, not a read.
+
+```ruby
+@foo &&= 1
+```
+
+## Common mistakes
+
+#### Implicitly depending on undefined instance variables
+
+```ruby
+def description
+  return @description if @description.present?
+  @description = get_description
+end
+```
+
+This example is relying on Ruby’s behaviour of returning `nil` for undefiend instance variables, which is completely unnecessary. Instead of using `present?`, we could use `defined?` here.
+
+```ruby
+def description
+  return @description if defined?(@description)
+  @description = get_description
+end
+```
+
+Alternatively, as long as `get_description` doesn’t return `nil` and expect us to memoize it, we could use an “or-write” `||=`
+
+```ruby
+def description
+  @description ||= get_description
+end
+```
+
+#### Rendering instance variables that are only set somtimes
+
+It’s common to render an instance variable in an ERB view that you only set on some controllers.
+
+```erb
+<div data-favourites="<%= @user_favourites %>"></div>
+```
+
+The best solution to this to always set it on all controllers, but set it to `nil` in the cases where you don’t have anything to render. This will prevent you from making a typo in your views.
+
+Alternatively, you could update the view to be explicit about the fact this ivar may not be set.
+
+```erb
+<div data-favourites="<%= (@user_favourites ||= nil) %>"></div>
+```
+
+Better yet, add a `defined?` check:
+
+```erb
+<% if defined?(@user_favourites) %>
+  <div data-favourites="<%= @user_favourites %>"></div>
+<% end %>
+```
+
+## Performance
+
+#### Boot performance
+
+Using Strict Ivars will impact startup performance since it needs to process each Ruby file you require. However, if you are using Bootsnap, the processed RubyVM::InstructionSequences will be cached and you probably won’t notice the incremental cache misses day-to-day.
+
+#### Runtime performance
+
+In my benchmarks on Ruby 3.4 with YJIT, it’s difficult to tell if there is any performance difference with or without the `defined?` guards at runtime. Sometimes it’s about 1% faster with the guards than without. Sometimes the other way around.
+
+On my laptop, a method that returns an instance varible takes about 15ns and a method that checks if an instance varible is defined and then returns it takes about 15ns. All this is to say, I don’t think there will be any measurable runtime performance impact, at least not in Ruby 3.4.
+
+#### Dynamic evals
+
+There is a small additional cost to dynamically evaluating code via `eval`, `class_eval`, `module_eval`, `instance_eval` and `binding.eval`. Dynamic evaluation usually only happens at boot time but it can happen at runtime depending on how you use it.
+
+## Stability
+
+Strict Ivars has 100% line and branch coverage and there are no known false-positives, false-negatives or bugs.
+
+## Uninstall
+
+Becuase Strict Ivars only ever makes your code safer, you can always back out without anything breaking.
+
+To uninstall Strict Ivars, first remove the require and initialization code from wherever you added it and then remove the gem from your `Gemfile`. If you are using Bootsnap, there’s a good chance it cached some pre-processed code with the instance variable read guards in it. To clear this, you’ll need to delete your bootsnap cache, which should be in `tmp/cache/bootsnap`.

data/lib/empirical/base_processor.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+class Empirical::BaseProcessor < Prism::Visitor
+	EVAL_METHODS = Set[:class_eval, :module_eval, :instance_eval, :eval].freeze
+
+	#: (String) -> String
+	def self.call(source)
+		visitor = new
+		visitor.visit(Prism.parse(source).value)
+		buffer = source.dup
+		annotations = visitor.annotations
+		annotations.sort_by!(&:first)
+
+		annotations.reverse_each do |offset, length, string|
+			buffer[offset, length] = string
+		end
+
+		buffer
+	end
+
+	def initialize
+		@context = Set[]
+		@annotations = []
+	end
+
+	#: Array[[Integer, String]]
+	attr_reader :annotations
+
+	def visit_call_node(node)
+		name = node.name
+
+		if EVAL_METHODS.include?(name) && (arguments = node.arguments)
+			location = arguments.location
+
+			closing = if arguments.contains_forwarding?
+				")), &(::Empirical.__eval_block_from_forwarding__(...))"
+			else
+				"))"
+			end
+
+			if node.receiver
+				receiver_local = "__eval_receiver_#{SecureRandom.hex(8)}__"
+				receiver_location = node.receiver.location
+
+				@annotations.push(
+					[receiver_location.start_character_offset, 0, "(#{receiver_local} = "],
+					[receiver_location.end_character_offset, 0, ")"],
+					[location.start_character_offset, 0, "*(::Empirical.__process_eval_args__(#{receiver_local}, :#{name}, "],
+					[location.end_character_offset, 0, closing]
+				)
+			else
+				@annotations.push(
+					[location.start_character_offset, 0, "*(::Empirical.__process_eval_args__(self, :#{name}, "],
+					[location.end_character_offset, 0, closing]
+				)
+			end
+		end
+
+		super
+	end
+end

data/lib/empirical/configuration.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+class Empirical::Configuration
+	def initialize
+		@mutex = Mutex.new
+		@include = []
+		@exclude = []
+	end
+
+	#: (*String) -> void
+	def include(*patterns)
+		@mutex.synchronize do
+			@include.concat(patterns)
+		end
+	end
+
+	#: (*String) -> void
+	def exclude(*patterns)
+		@mutex.synchronize do
+			@exclude.concat(patterns)
+		end
+	end
+
+	#: (String) -> bool
+	def match?(path)
+		return false unless String === path
+		path = File.absolute_path(path)
+		return false if @exclude.any? { |pattern| File.fnmatch?(pattern, path) }
+		return true if @include.any? { |pattern| File.fnmatch?(pattern, path) }
+		false
+	end
+end

data/lib/empirical/name_error.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "did_you_mean/spell_checker"
+
+class Empirical::NameError < ::NameError
+	INSTANCE_VARIABLE_METHOD = Kernel.instance_method(:instance_variables)
+
+	def initialize(object, name)
+		checker = DidYouMean::SpellChecker.new(
+			dictionary: INSTANCE_VARIABLE_METHOD.bind_call(object)
+		)
+
+		suggestion = checker.correct(name).first
+
+		message = [
+			"Undefined instance variable `#{name}`.",
+			("Did you mean `#{suggestion}`?" if suggestion),
+		].join(" ")
+
+		super(message)
+	end
+end

data/lib/empirical/processor.rb

@@ -0,0 +1,257 @@
+# frozen_string_literal: true
+
+class Empirical::Processor < Empirical::BaseProcessor
+	#: (Prism::ClassNode) -> void
+	def visit_class_node(node)
+		new_context { super }
+	end
+
+	#: (Prism::ModuleNode) -> void
+	def visit_module_node(node)
+		new_context { super }
+	end
+
+	#: (Prism::BlockNode) -> void
+	def visit_block_node(node)
+		new_context { super }
+	end
+
+	#: (Prism::SingletonClassNode) -> void
+	def visit_singleton_class_node(node)
+		new_context { super }
+	end
+
+	#: (Prism::IfNode) -> void
+	def visit_if_node(node)
+		visit(node.predicate)
+
+		branch { visit(node.statements) }
+		branch { visit(node.subsequent) }
+	end
+
+	#: (Prism::CaseNode) -> void
+	def visit_case_node(node)
+		visit(node.predicate)
+
+		node.conditions.each do |condition|
+			branch { visit(condition) }
+		end
+
+		branch { visit(node.else_clause) }
+	end
+
+	#: (Prism::DefinedNode) -> void
+	def visit_defined_node(node)
+		value = node.value
+
+		return if Prism::InstanceVariableReadNode === value
+
+		super
+	end
+
+	#: (Prism::InstanceVariableReadNode) -> void
+	def visit_instance_variable_read_node(node)
+		name = node.name
+
+		unless @context.include?(name)
+			location = node.location
+
+			@context << name
+
+			@annotations.push(
+				[location.start_character_offset, 0, "(defined?(#{name}) ? "],
+				[location.end_character_offset, 0, " : (::Kernel.raise(::Empirical::NameError.new(self, :#{name}))))"]
+			)
+		end
+
+		super
+	end
+
+	#: () { () -> void } -> void
+	private def new_context
+		original_context = @context
+
+		@context = Set[]
+
+		begin
+			yield
+		ensure
+			@context = original_context
+		end
+	end
+
+	#: () { () -> void } -> void
+	private def branch
+		original_context = @context
+		@context = original_context.dup
+
+		begin
+			yield
+		ensure
+			@context = original_context
+		end
+	end
+
+	def visit_def_node(node)
+		new_context do
+			return super unless node.equal_loc
+			return super unless node in {
+				body: {
+					body: [
+						Prism::CallNode[
+							block: Prism::BlockNode[
+								body: Prism::StatementsNode
+							] => block
+						] => call
+					]
+				}
+			}
+
+			signature = build_typed_parameters_assertion(node)
+
+			if node.rparen_loc
+				@annotations << [
+					start = node.rparen_loc.start_offset + 1,
+					block.opening_loc.end_offset - start,
+					";binding.assert(#{signature});__literally_returns__ = (;",
+				]
+			else
+				@annotations << [
+					start = node.equal_loc.start_offset - 1,
+					block.opening_loc.end_offset - start,
+					";__literally_returns__ = (;",
+				]
+			end
+
+			return_type = if call.closing_loc
+				node.slice[(call.start_offset)...(call.closing_loc.end_offset)]
+			else
+				call.name
+			end
+			@annotations << [
+				block.closing_loc.start_offset,
+				0,
+				";);binding.assert(__literally_returns__: #{return_type});__literally_returns__;",
+			]
+
+			@annotations << [
+				start = block.closing_loc.start_offset,
+				block.closing_loc.end_offset - start,
+				"end",
+			]
+		end
+	end
+
+	private def build_typed_parameters_assertion(node)
+		return unless node.parameters
+
+		if (requireds = node.parameters.requireds)&.any?
+			raise Empirical::TypedSignatureError.new("Typed method signatures don't allow required keyword parameters: #{requireds.inspect}")
+		elsif (rest = node.parameters.rest)&.any?
+			raise Empirical::TypedSignatureError.new("Typed method signatures don't allow a splat array parameter: #{rest.inspect}")
+		elsif (posts = node.parameters.posts)&.any?
+			raise Empirical::TypedSignatureError.new("Typed method signatures don't allow a splat hash parameter: #{posts.inspect}")
+		elsif (keyword_rest = node.parameters.keyword_rest)&.any?
+			raise Empirical::TypedSignatureError.new("Typed method signatures don't allow a splat hash parameter: #{keyword_rest.inspect}")
+		end
+
+		parameters_assertions = []
+
+		if (optionals = node.parameters.optionals)&.any?
+			parameters_assertions << optionals.map do |optional|
+				case optional
+				# typed splats, e.g.
+				# `(names = [String])` => `(*names); assert(names: _Array(String))` and
+				# `(position = [*Position])` => `(*position); assert(position: Position)`
+				in { value: Prism::ArrayNode[elements: [type_node]] => value }
+					if type_node in Prism::SplatNode
+						type = type_node.expression.slice
+					else
+						type = "::Literal::_Array(#{type_node.slice})"
+					end
+
+					# Make the parameter a splat
+					@annotations << [optional.name_loc.start_offset, 0, "*"]
+
+					# Remove the type signature (the default value)
+					@annotations << [optional.operator_loc.start_offset, value.closing_loc.end_offset - optional.operator_loc.start_offset, ""]
+					next "#{optional.name}: #{type}"
+				# With default
+				in {
+					value: Prism::CallNode[
+						block: Prism::BlockNode[
+							body: Prism::StatementsNode => default_node
+						]
+					] => call
+				}
+					default = "(#{default_node.slice})"
+
+					type = if call.closing_loc
+						node.slice[(call.start_offset)...(call.closing_loc.end_offset)]
+					else
+						call.name
+					end
+				# No default
+				else
+					default = "nil"
+					type = optional.value.slice
+				end
+
+				value_location = optional.value.location
+				@annotations << [value_location.start_offset, value_location.end_offset - value_location.start_offset, default]
+				"#{optional.name}: #{type}"
+			end.join(", ")
+		end
+
+		if (keywords = node.parameters.keywords)&.any?
+			parameters_assertions << keywords.map do |keyword|
+				case keyword
+				# Splat
+				in { value: Prism::HashNode[elements: [Prism::AssocNode[key: key_type_node, value: val_type_node]]] => value }
+					type = "::Literal::_Hash(#{key_type_node.slice}, #{val_type_node.slice})"
+
+					# Make the parameter a splat
+					@annotations << [keyword.name_loc.start_offset, 0, "**"]
+
+					# Remove the type signature (the default value) and the colon at the end of the keyword
+					@annotations << [keyword.name_loc.end_offset - 1, value.closing_loc.end_offset - keyword.name_loc.end_offset + 1, ""]
+					next "#{keyword.name}: #{type}"
+				in { value: Prism::HashNode[elements: [Prism::AssocSplatNode[value: val_type_node]]] => value }
+					type = val_type_node.slice
+
+					# Make the parameter a splat
+					@annotations << [keyword.name_loc.start_offset, 0, "**"]
+
+					# Remove the type signature (the default value) and the colon at the end of the keyword
+					@annotations << [keyword.name_loc.end_offset - 1, value.closing_loc.end_offset - keyword.name_loc.end_offset + 1, ""]
+					next "#{keyword.name}: #{type}"
+				# With default
+				in {
+					value: Prism::CallNode[
+						block: Prism::BlockNode[
+							body: Prism::StatementsNode => default_node
+						]
+					] => call
+				}
+					default = "(#{default_node.slice})"
+
+					type = if call.closing_loc
+						node.slice[(call.start_offset)...(call.closing_loc.end_offset)]
+					else
+						call.name
+					end
+				# No default
+				else
+					default = "nil"
+					type = keyword.value.slice
+				end
+
+				value_location = keyword.value.location
+				@annotations << [value_location.start_offset, value_location.end_offset - value_location.start_offset, default]
+				"#{keyword.name}: #{type}"
+			end.join(", ")
+		end
+
+		parameters_assertions.join(", ")
+	end
+end

data/lib/empirical/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Empirical
+	VERSION = "0.0.1"
+end

data/lib/empirical.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require "set"
+require "prism"
+require "securerandom"
+
+require "empirical/version"
+require "empirical/name_error"
+require "empirical/base_processor"
+require "empirical/processor"
+require "empirical/configuration"
+
+require "require-hooks/setup"
+
+module Empirical
+	EMPTY_ARRAY = [].freeze
+	EVERYTHING = ["**/*"].freeze
+	METHOD_METHOD = Module.instance_method(:method)
+
+	CONFIG = Configuration.new
+	TypedSignatureError = Class.new(StandardError)
+
+	# Initializes Empirical so that code loaded after this point will be
+	# guarded against undefined instance variable reads. You can pass an array
+	# of globs to `include:` and `exclude:`.
+	#
+	# ```ruby
+	# Empirical.init(
+	#   include: ["#{Dir.pwd}/**/*"],
+	#   exclude: ["#{Dir.pwd}/vendor/**/*"]
+	# )
+	# ```
+	#: (include: Array[String], exclude: Array[String]) -> void
+	def self.init(include: EMPTY_ARRAY, exclude: EMPTY_ARRAY)
+		CONFIG.include(*include)
+		CONFIG.exclude(*exclude)
+
+		RequireHooks.source_transform(
+			patterns: EVERYTHING,
+			exclude_patterns: EMPTY_ARRAY
+		) do |path, source|
+			source ||= File.read(path)
+
+			if CONFIG.match?(path)
+				Processor.call(source)
+			else
+				BaseProcessor.call(source)
+			end
+		end
+	end
+
+	# For internal use only. This method pre-processes arguments to an eval method.
+	#: (Object, Symbol, *untyped)
+	def self.__process_eval_args__(receiver, method_name, *args)
+		method = METHOD_METHOD.bind_call(receiver, method_name)
+		owner = method.owner
+
+		source, file = nil
+
+		case method_name
+		when :class_eval, :module_eval
+			if Module == owner
+				source, file = args
+			end
+		when :instance_eval
+			if BasicObject == owner
+				source, file = args
+			end
+		when :eval
+			if Kernel == owner
+				source, binding, file = args
+			elsif Binding == owner
+				source, file = args
+			end
+		end
+
+		if String === source
+			file ||= caller_locations(1, 1).first.path
+
+			if CONFIG.match?(file)
+				args[0] = Processor.call(source)
+			else
+				args[0] = BaseProcessor.call(source)
+			end
+		end
+
+		args
+	rescue ::NameError
+		args
+	end
+
+	#: () { () -> void } -> Proc
+	def self.__eval_block_from_forwarding__(*, &block)
+		block
+	end
+end

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: empirical
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Joel Drapper
+- Stephen Margheim
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: require-hooks
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: prism
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Based on, concerned with, or verifiable by observation or experience
+  rather than theory or pure logic.
+email:
+- joel@drapper.me
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/empirical.rb
+- lib/empirical/base_processor.rb
+- lib/empirical/configuration.rb
+- lib/empirical/name_error.rb
+- lib/empirical/processor.rb
+- lib/empirical/version.rb
+homepage: https://github.com/yippee-fun/empirical
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/yippee-fun/empirical
+  source_code_uri: https://github.com/yippee-fun/empirical
+  funding_uri: https://github.com/sponsors/joeldrapper
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Based on, concerned with, or verifiable by observation or experience rather
+  than theory or pure logic.
+test_files: []