prop_initializer 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 96c417df7010839148ad78bae4904f00cc9fd4384a35acb7745633b818beb8bd
-  data.tar.gz: ec4a050a9ef18d35e878675f44e93f0df30f076bd67b7d59a261cdd0449c0cc1
+  metadata.gz: 4dc72d5e414e9bd4690aeab766d53f8d00258f9a917ad40ca74300acab1cec12
+  data.tar.gz: '068996afcdb7cb460c9fcf90b8bec7b30b5694675628b1f9efc0799b6e6e9aaa'
 SHA512:
-  metadata.gz: 944054343092908cf84a2a7e2f072ab1d6536ed943182d25714b80f68818afc68bc35cc0b95a8b7e92261938db453eb66fe40a2a84ccfb174e3b231943ac6124
-  data.tar.gz: fd1e6b8d424d7c8ff1b28461e2bc99b9acf263fd38eef77d5f17169ee94275f4ddcf2e39af1e5654ec9135466ab757d78a9bbef666eb9026bf09b9c3903954ac
+  metadata.gz: b9393c607fb3f5fcf2e2cac36d69ea4bd07c5bcdad53954e32b34f599ce037f86ccacae6d050312b5b2a879e558521aad77113a94548c64ed371f5fb4f43f1ee
+  data.tar.gz: 14ec41b36d29501ef2e8cf8f58993a5f63d0549c3eebc8e182ee3e49c27b15e4522db669919c28caddb788e82361ece5bd1a9f6dee99dce7ab32c3de6d4e44e3

data/README.md

@@ -2,19 +2,19 @@
 
 # Prop Initializer
 
+![prop_initializer: properties for any Ruby class. One prop line per property; the initializer, readers, writers and to_h are generated once, when the class loads. Built on Literal, used by Avo's components. Left: a ButtonComponent declaring props with a positional kind, a public reader, a default, a proc default and a coercion block. Right: the initialize, attr_reader and to_h it generates. Below, five notes: every argument kind; defaults; coercion blocks; readers, writers and predicates; after_initialize.](./banner.png)
+
 ## Overview
 
 The `prop_initializer` gem is a flexible tool for defining properties on Ruby classes.
 
-![](./logo.png)
-
 It's a fork of the [Literal Gem](https://github.com/joeldrapper/literal), with a few tweaks. We sincerely thank [Joel Drapper](https://github.com/joeldrapper) for the inspiration and base code that made this possible.
 
 With `prop_initializer`, you can easily declare properties for any class, giving you flexible options for default values and more. However, the scope is narrowed down by removing strict typing requirements, providing a more lightweight and adaptable interface.
 
 ## Installation
 
-To use `prop_initializer ` in your Ruby project, add the following to your Gemfile:
+To use `prop_initializer` in your Ruby project, add the following to your Gemfile:
 
 ```ruby
 gem "prop_initializer"
@@ -28,7 +28,7 @@ bundle install
 
 ## Usage
 
-To start using `prop_initializer `, you need to include the module in the class where you want to define properties.
+To start using `prop_initializer`, you need to extend the class with the module where you want to define properties.
 
 ### Step 1: Extend the Properties Module
 
@@ -42,7 +42,7 @@ end
 
 ### Step 2: Define Properties
 
-Properties can be declared using the `prop` method, which generates writers and makes them available as instance variables (e.g., `@name`, `@size`, etc.).
+Properties can be declared using the `prop` method. The generated initializer assigns each one to an instance variable (e.g., `@name`, `@size`, etc.).
 
 #### Basic Syntax:
 
@@ -53,6 +53,13 @@ prop :args, kind: :*      # A property for handling splat arguments
 prop :kwargs, kind: :**   # A property for handling keyword arguments
 ```
 
+A default must be a frozen value or a proc. A proc runs on each new instance once the positional and splat properties, and the keyword properties declared before it, are assigned, so it can read them:
+
+```ruby
+prop :count, default: 2
+prop :items, default: -> { Array.new(@count) }
+```
+
 #### Custom Property with Block:
 
 You can define a custom processing block when declaring a property, for example:
@@ -65,7 +72,7 @@ end
 
 ### Step 3: Accessing Properties
 
-By default, `PropInitializer` generates a writer for each declared property. The properties are stored as instance variables, which can be accessed within the class:
+By default, `PropInitializer` generates no reader or writer. The properties are stored as instance variables, which can be accessed within the class:
 
 ```ruby
 @name    # Accesses the value of the 'name' property
@@ -86,6 +93,14 @@ This will automatically generate a public getter method, allowing you to retriev
 my_class_instance.title  # Public getter for the 'title' property
 ```
 
+#### Writer and Predicate:
+
+`writer: :public` adds a setter and `predicate: :public` a `title?` method. A setter runs the property's block, if it has one, the same way the initializer does.
+
+#### after_initialize:
+
+Define `after_initialize`, public or private, and it runs once every property is assigned.
+
 ### Example:
 
 ```ruby

data/Rakefile

@@ -1,3 +1,9 @@
-require "bundler/setup"
-
 require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task default: :test

data/lib/prop_initializer/null.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
 module PropInitializer::Null
-	def self.inspect
-		"PropInitializer::Null"
-	end
+  def self.inspect
+    "PropInitializer::Null"
+  end
 
-	freeze
+  freeze
 end

data/lib/prop_initializer/properties/schema.rb

@@ -2,118 +2,125 @@
 
 # @api private
 class PropInitializer::Properties::Schema
-	include Enumerable
-
-	def initialize(properties_index: {}, sorted_properties: [])
-		@properties_index = properties_index
-		@sorted_properties = sorted_properties
-		@mutex = Mutex.new
-	end
-
-	attr_reader :properties_index
-
-	def [](key)
-		@properties_index[key]
-	end
-
-	def <<(value)
-		@mutex.synchronize do
-			@properties_index[value.name] = value
-			# ruby's sort is unstable, this trick makes it stable
-			n = 0
-			@sorted_properties = @properties_index.values.sort_by! { |it| n += 1; [it, n] }
-		end
-
-		self
-	end
-
-	def dup
-		self.class.new(
-			properties_index: @properties_index.dup,
-			sorted_properties: @sorted_properties.dup,
-		)
-	end
-
-	def each(&)
-		@sorted_properties.each(&)
-	end
-
-	def size
-		@sorted_properties.size
-	end
-
-	def generate_initializer(buffer = +"")
-		buffer << "def initialize(#{generate_initializer_params})\n"
-		generate_initializer_body(buffer)
-		buffer << "" \
-			"  after_initialize if respond_to?(:after_initialize)\n" \
-			"end\n"
-	end
-
-	def generate_to_h(buffer = +"")
-		buffer << "def to_h\n" << "  {\n"
-
-		sorted_properties = @sorted_properties
-		i, n = 0, sorted_properties.size
-		while i < n
-			property = sorted_properties[i]
-			buffer << "    " << property.name.name << ": @" << property.name.name << ",\n"
-			i += 1
-		end
-
-		buffer << "  }\n" << "end\n"
-	end
-
-	private
-
-	def generate_initializer_params(buffer = +"")
-		sorted_properties = @sorted_properties
-		i, n = 0, sorted_properties.size
-		while i < n
-			property = sorted_properties[i]
-
-			case property.kind
-			when :*
-				buffer << "*" << property.escaped_name
-			when :**
-				buffer << "**" << property.escaped_name
-			when :&
-				buffer << "&" << property.escaped_name
-			when :positional
-				if property.default?
-					buffer << property.escaped_name << " = PropInitializer::Null"
-				else
-					buffer << property.escaped_name << " = nil"
-				end
-			when :keyword
-				if property.default?
-					buffer << property.name.name << ": PropInitializer::Null"
-				else
-					buffer << property.name.name << ": nil"
-				end
-			else
-				raise "You should never see this error."
-			end
-
-			i += 1
-			buffer << ", " if i < n
-		end
-
-		buffer
-	end
-
-	def generate_initializer_body(buffer = +"")
-		buffer << "  properties = self.class.prop_initializer_properties.properties_index\n"
-		generate_initializer_handle_properties(@sorted_properties, buffer)
-	end
-
-	def generate_initializer_handle_properties(properties, buffer = +"")
-		i, n = 0, properties.size
-		while i < n
-			properties[i].generate_initializer_handle_property(buffer)
-			i += 1
-		end
-
-		buffer
-	end
+  include Enumerable
+
+  def initialize(properties_index: {}, sorted_properties: [])
+    @properties_index = properties_index
+    @sorted_properties = sorted_properties
+    @mutex = Mutex.new
+  end
+
+  attr_reader :properties_index
+
+  def [](key)
+    @properties_index[key]
+  end
+
+  def <<(value)
+    @mutex.synchronize do
+      @properties_index[value.name] = value
+      # ruby's sort is unstable, this trick makes it stable
+      n = 0
+      @sorted_properties = @properties_index.values.sort_by! { |it| n += 1; [ it, n ] }
+    end
+
+    self
+  end
+
+  def dup
+    self.class.new(
+      properties_index: @properties_index.dup,
+      sorted_properties: @sorted_properties.dup,
+    )
+  end
+
+  def each(&)
+    @sorted_properties.each(&)
+  end
+
+  def size
+    @sorted_properties.size
+  end
+
+  def generate_initializer(buffer = +"")
+    buffer << "alias initialize initialize\n" \
+      "def initialize(#{generate_initializer_params})\n"
+    generate_initializer_body(buffer)
+    buffer << "" \
+      "  after_initialize() if respond_to?(:after_initialize, true)\n" \
+      "end\n"
+  end
+
+  def generate_to_h(buffer = +"")
+    buffer << "alias to_h to_h\n" \
+      "def to_h\n" << "  {\n"
+
+    sorted_properties = @sorted_properties
+    i, n = 0, sorted_properties.size
+    while i < n
+      property = sorted_properties[i]
+      buffer << "    " << property.name.name << ": @" << property.name.name << ",\n"
+      i += 1
+    end
+
+    buffer << "  }\n" << "end\n"
+  end
+
+  private
+
+  def generate_initializer_params(buffer = +"")
+    sorted_properties = @sorted_properties
+    i, n = 0, sorted_properties.size
+    while i < n
+      property = sorted_properties[i]
+
+      case property.kind
+      when :*
+        buffer << "*" << property.escaped_name
+      when :**
+        buffer << "**" << property.escaped_name
+      when :&
+        buffer << "&" << property.escaped_name
+      when :positional
+        buffer << property.escaped_name << " = " << generate_initializer_default(property)
+      when :keyword
+        buffer << property.name.name << ": " << generate_initializer_default(property)
+      else
+        raise "You should never see this error."
+      end
+
+      i += 1
+      buffer << ", " if i < n
+    end
+
+    buffer
+  end
+
+  def generate_initializer_default(property)
+    if property.inline_default?
+      property.default.inspect
+    elsif property.default?
+      "PropInitializer::Null"
+    else
+      "nil"
+    end
+  end
+
+  def generate_initializer_body(buffer = +"")
+    if @sorted_properties.any?(&:lookup?)
+      buffer << "  __pi_properties = self.class.prop_initializer_properties.properties_index\n"
+    end
+
+    generate_initializer_handle_properties(@sorted_properties, buffer)
+  end
+
+  def generate_initializer_handle_properties(properties, buffer = +"")
+    i, n = 0, properties.size
+    while i < n
+      properties[i].generate_initializer_handle_property(buffer)
+      i += 1
+    end
+
+    buffer
+  end
 end

data/lib/prop_initializer/properties.rb

@@ -13,7 +13,7 @@ module PropInitializer::Properties
     end
 
     unless PropInitializer::Property::VISIBILITY_OPTIONS.include?(predicate)
-        raise ArgumentError.new(p"The predicate must be one of #{PropInitializer::Property::VISIBILITY_OPTIONS.map(&:inspect).join(', ')}.")
+        raise ArgumentError.new("The predicate must be one of #{PropInitializer::Property::VISIBILITY_OPTIONS.map(&:inspect).join(', ')}.")
     end
 
     if reader && :class == name
@@ -39,6 +39,8 @@ module PropInitializer::Properties
     prop_initializer_properties << property
     __define_prop_initializer_methods__(property)
     include(__prop__initializer_extension__)
+
+    name
   end
 
   def prop_initializer_properties
@@ -67,7 +69,17 @@ module PropInitializer::Properties
     if defined?(@__prop__initializer_extension__)
       @__prop__initializer_extension__
     else
-      @__prop__initializer_extension__ = Module.new
+      @__prop__initializer_extension__ = Module.new do
+        set_temporary_name "PropInitializer::Properties(Extension)" if respond_to?(:set_temporary_name)
+
+        def initialize
+          after_initialize if respond_to?(:after_initialize, true)
+        end
+
+        def to_h
+          {}
+        end
+      end
     end
   end
 

data/lib/prop_initializer/property.rb

@@ -1,184 +1,187 @@
 # frozen_string_literal: true
 
 class PropInitializer::Property
-	ORDER = { :positional => 0, :* => 1, :keyword => 2, :** => 3, :& => 4 }.freeze
-	RUBY_KEYWORDS = %i[alias and begin break case class def do else elsif end ensure false for if in module next nil not or redo rescue retry return self super then true undef unless until when while yield].to_h { |k| [k, "__#{k}__"] }.freeze
-	GENERATOR_PROPERTY_LOCAL = "__pi_prop"
-
-	VISIBILITY_OPTIONS = Set[false, :private, :protected, :public].freeze
-	KIND_OPTIONS = Set[:positional, :*, :keyword, :**, :&].freeze
-
-	include Comparable
-
-	def initialize(name:, kind:, reader:, writer:, predicate:, default:, coercion:)
-		@name = name
-		@kind = kind
-		@reader = reader
-		@writer = writer
-		@predicate = predicate
-		@default = default
-		@coercion = coercion
-	end
-
-	attr_reader :name, :kind, :reader, :writer, :predicate, :default, :coercion
-
-	def optional?
-		default?
-	end
-
-	def required?
-		!optional?
-	end
-
-	def keyword?
-		@kind == :keyword
-	end
-
-	def positional?
-		@kind == :positional
-	end
-
-	def splat?
-		@kind == :*
-	end
-
-	def double_splat?
-		@kind == :**
-	end
-
-	def block?
-		@kind == :&
-	end
-
-	def default?
-		nil != @default
-	end
-
-	def param
-		case @kind
-		when :*
-			"*#{escaped_name}"
-		when :**
-			"**#{escaped_name}"
-		when :&
-			"&#{escaped_name}"
-		when :positional
-			escaped_name
-		when :keyword
-			"#{@name.name}:"
-		else
-			raise "You should never see this error."
-		end
-	end
-
-	def <=>(other)
-		ORDER[@kind] <=> ORDER[other.kind]
-	end
-
-	def coerce(value, context:)
-		context.instance_exec(value, &@coercion)
-	end
-
-	def ruby_keyword?
-		!!RUBY_KEYWORDS[@name]
-	end
-
-	def escaped_name
-		RUBY_KEYWORDS[@name] || @name.name
-	end
-
-	def default_value
-		case @default
-			when Proc then @default.call
-			else @default
-		end
-	end
-
-	def generate_reader_method(buffer = +"")
-		buffer <<
-			(@reader ? @reader.name : "public") <<
-			"\ndef " <<
-			@name.name <<
-			"\n  value = @" <<
-			@name.name <<
-			"\n  value\nend\n"
-	end
-
-	def generate_writer_method(buffer = +"")
-		buffer <<
-			(@writer ? @writer.name : "public") <<
-			" def " <<
-			@name.name <<
-			"=(value)\n" <<
-			"  @#{@name.name} = value\nend\n"
-	end
-	
-	def generate_predicate_method(buffer = +"")
-		buffer <<
-			(@predicate ? @predicate.name : "public") <<
-			" def " <<
-			@name.name <<
-			"?\n" <<
-			"  !!@" <<
-			@name.name <<
-			"\n" <<
-			"end\n"
-	end
-
-	def generate_initializer_handle_property(buffer = +"")
-		buffer << "  # " << @name.name << "\n" <<
-			"  #{GENERATOR_PROPERTY_LOCAL} = properties[:" << @name.name << "]\n"
-
-		if @kind == :keyword && ruby_keyword?
-			generate_initializer_escape_keyword(buffer)
-		end
-
-		if default?
-			generate_initializer_assign_default(buffer)
-		end
-
-		if @coercion
-			generate_initializer_coerce_property(buffer)
-		end
-
-		generate_initializer_assign_value(buffer)
-	end
-
-	private
-
-	def generate_initializer_escape_keyword(buffer = +"")
-		buffer <<
-			escaped_name <<
-			" = binding.local_variable_get(:" <<
-			@name.name <<
-			")\n"
-	end
-
-	def generate_initializer_coerce_property(buffer = +"")
-		buffer <<
-			escaped_name <<
-			"= #{GENERATOR_PROPERTY_LOCAL}.coerce(" <<
-			escaped_name <<
-			", context: self)\n"
-	end
-
-	def generate_initializer_assign_default(buffer = +"")
-		buffer <<
-			"  if " <<
-			((@kind == :&) ? "nil" : "PropInitializer::Null") <<
-			" == " <<
-			escaped_name <<
-			"\n    " <<
-			escaped_name <<
-			" = #{GENERATOR_PROPERTY_LOCAL}.default_value\n  end\n"
-	end
-
-	def generate_initializer_assign_value(buffer = +"")
-		buffer <<
-			"  @" <<
-			@name.name <<
-			" = " <<
-			escaped_name <<
-			"\n"
-	end
+  ORDER = { :positional => 0, :* => 1, :keyword => 2, :** => 3, :& => 4 }.freeze
+  RUBY_KEYWORDS = %i[alias and begin break case class def do else elsif end ensure false for if in module next nil not or redo rescue retry return self super then true undef unless until when while yield].to_h { |k| [ k, "__#{k}__" ] }.freeze
+  GENERATOR_PROPERTY_LOCAL = "__pi_prop"
+
+  VISIBILITY_OPTIONS = Set[false, :private, :protected, :public].freeze
+  KIND_OPTIONS = Set[:positional, :*, :keyword, :**, :&].freeze
+
+  include Comparable
+
+  def initialize(name:, kind:, reader:, writer:, predicate:, default:, coercion:)
+    @name = name
+    @kind = kind
+    @reader = reader
+    @writer = writer
+    @predicate = predicate
+    @default = default
+    @coercion = coercion
+  end
+
+  attr_reader :name, :kind, :reader, :writer, :predicate, :default, :coercion
+
+  def optional?
+    default?
+  end
+
+  def required?
+    !optional?
+  end
+
+  def keyword?
+    @kind == :keyword
+  end
+
+  def positional?
+    @kind == :positional
+  end
+
+  def splat?
+    @kind == :*
+  end
+
+  def double_splat?
+    @kind == :**
+  end
+
+  def block?
+    @kind == :&
+  end
+
+  def default?
+    nil != @default
+  end
+
+  # Symbol, Integer, true and false go into the signature as literals, so the initializer never looks the
+  # property up. Not for a block parameter, and not for a Symbol the generated UTF-8 source cannot spell.
+  def inline_default?
+    return false unless positional? || keyword?
+
+    Integer === @default || true == @default || false == @default ||
+      (Symbol === @default && (Encoding::UTF_8 == @default.encoding || Encoding::US_ASCII == @default.encoding))
+  end
+
+  def lookup?
+    (default? && !inline_default?) || !!@coercion
+  end
+
+  def param
+    case @kind
+    when :*
+      "*#{escaped_name}"
+    when :**
+      "**#{escaped_name}"
+    when :&
+      "&#{escaped_name}"
+    when :positional
+      escaped_name
+    when :keyword
+      "#{@name.name}:"
+    else
+      raise "You should never see this error."
+    end
+  end
+
+  def <=>(other)
+    ORDER[@kind] <=> ORDER[other.kind]
+  end
+
+  def ruby_keyword?
+    !!RUBY_KEYWORDS[@name]
+  end
+
+  def escaped_name
+    RUBY_KEYWORDS[@name] || @name.name
+  end
+
+  def generate_reader_method(buffer = +"")
+    buffer << @reader.name << " attr_reader :" << @name.name << "\n"
+  end
+
+  def generate_writer_method(buffer = +"")
+    return buffer << @writer.name << " attr_writer :" << @name.name << "\n" unless @coercion
+
+    # Through self.class at call time, not captured: a subclass may redeclare the prop with another block,
+    # or with none, and still inherit this writer.
+    buffer <<
+      @writer.name << " def " << @name.name << "=(value)\n" \
+      "  coercion = self.class.prop_initializer_properties[:" << @name.name << "].coercion\n" \
+      "  @" << @name.name << " = coercion ? instance_exec(value, &coercion) : value\n" \
+      "end\n"
+  end
+
+  def generate_predicate_method(buffer = +"")
+    buffer <<
+      (@predicate ? @predicate.name : "public") <<
+      " def " <<
+      @name.name <<
+      "?\n" <<
+      "  !!@" <<
+      @name.name <<
+      "\n" <<
+      "end\n"
+  end
+
+  def generate_initializer_handle_property(buffer = +"")
+    buffer << "  # " << @name.name << "\n"
+
+    if lookup?
+      buffer << "  #{GENERATOR_PROPERTY_LOCAL} = __pi_properties[:" << @name.name << "]\n"
+    end
+
+    if @kind == :keyword && ruby_keyword?
+      generate_initializer_escape_keyword(buffer)
+    end
+
+    if default? && !inline_default?
+      generate_initializer_assign_default(buffer)
+    end
+
+    if @coercion
+      generate_initializer_coerce_property(buffer)
+    end
+
+    generate_initializer_assign_value(buffer)
+  end
+
+  private
+
+  def generate_initializer_escape_keyword(buffer = +"")
+    buffer <<
+      escaped_name <<
+      " = ::Kernel.binding.local_variable_get(:" <<
+      @name.name <<
+      ")\n"
+  end
+
+  def generate_initializer_coerce_property(buffer = +"")
+    buffer <<
+      "  " <<
+      escaped_name <<
+      " = instance_exec(" <<
+      escaped_name <<
+      ", &#{GENERATOR_PROPERTY_LOCAL}.coercion)\n"
+  end
+
+  def generate_initializer_assign_default(buffer = +"")
+    buffer <<
+      "  if " <<
+      ((@kind == :&) ? "nil" : "PropInitializer::Null") <<
+      " == " <<
+      escaped_name <<
+      "\n    " <<
+      escaped_name <<
+      " = " << (Proc === @default ? "instance_exec(&#{GENERATOR_PROPERTY_LOCAL}.default)" : "#{GENERATOR_PROPERTY_LOCAL}.default") << "\n  end\n"
+  end
+
+  def generate_initializer_assign_value(buffer = +"")
+    buffer <<
+      "  @" <<
+      @name.name <<
+      " = " <<
+      escaped_name <<
+      "\n"
+  end
 end

data/lib/prop_initializer/version.rb

@@ -1,3 +1,3 @@
 module PropInitializer
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 end

data/lib/prop_initializer.rb

@@ -1,5 +1,4 @@
 require "prop_initializer/version"
-require "prop_initializer/railtie"
 
 require "zeitwerk"
 
@@ -7,5 +6,4 @@ loader = Zeitwerk::Loader.for_gem
 loader.setup
 
 module PropInitializer
-  # Your code goes here...
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: prop_initializer
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Paul Bob
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-05-11 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: zeitwerk
@@ -41,15 +40,12 @@ files:
 - lib/prop_initializer/properties.rb
 - lib/prop_initializer/properties/schema.rb
 - lib/prop_initializer/property.rb
-- lib/prop_initializer/railtie.rb
 - lib/prop_initializer/version.rb
-- lib/tasks/prop_initializer_tasks.rake
 homepage: https://github.com/avo-hq/prop_initializer
 licenses:
 - MIT
 metadata:
   homepage_uri: https://github.com/avo-hq/prop_initializer
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -57,15 +53,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 3.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.22
-signing_key:
+rubygems_version: 4.0.16
 specification_version: 4
 summary: A flexible property initializer for Ruby classes inspired by the Literal
   gem.

data/lib/prop_initializer/railtie.rb

@@ -1,6 +0,0 @@
-require "rails/railtie"
-
-module PropInitializer
-  class Railtie < ::Rails::Railtie
-  end
-end

data/lib/tasks/prop_initializer_tasks.rake

@@ -1,4 +0,0 @@
-# desc "Explaining what the task does"
-# task :prop_initializer do
-#   # Task goes here
-# end