philosophal 1.1.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d09ac65f9fd7fa000c82fa1d9e77c85e22866d2a9a1ffdfa1a63e19b36cb909b
-  data.tar.gz: bdf93344392beabea229e214b1403e88749fd51839e68c9e675fb9566fad5e52
+  metadata.gz: d1bb80908d227d997cf25e816e00335f9c61328aa4eb285ee7c51632adfcc9cb
+  data.tar.gz: 56ca323ff898cb43b8604850e0ea94cd5b323c236d365a70ad8d36e9321bd01f
 SHA512:
-  metadata.gz: f729b3f0a820e25d39e9de2eecd47cc7cd7bc12fa32cdc6306c81b02418f98507a3d814582f638822834dc3f9cae055b00db909a3cc66c3112c7ccb8118aaf90
-  data.tar.gz: a1ab12ea326c278c6d7eab6b555605642f0ce34d30d27782efe4a6991cbd3fc3b63917cbef00a8b21133b47e096056b2ba34234b40017239d556880960fa67f0
+  metadata.gz: 2cf9f37bd111eb6ca5c021a5fefd0da9b7cf48e624adf5ac9d12c57f885315b327ae1539946744317fbd120623455b82fe5d9aa3186a0613d9cb72f2102785ec
+  data.tar.gz: 70f39c48ee39f045a7208e141b1cd56c7cff8f6871e17a855628d2b85007ee7fe850df89fa084615eb26585078a5f0b4e2623e45b1d0befb59c4a9f62af4ba3c

data/CHANGELOG.md

@@ -1,4 +1,14 @@
-## [Unreleased]
+## [1.3.0] - 2026-10-19
+
+- Breaking: minimum required Ruby version is now **3.3** (was 3.1)
+- Breaking: assigning `nil` no longer converts it (e.g. to `0` or `""`); the property is reset and its reader returns the default value
+- Fix: converting a Numeric to **DateTime** no longer requires ActiveSupport (`Time.zone`)
+- Fix: properties declared in a subclass no longer leak into the parent class
+- Fix: a property set to `false` is no longer replaced by its default value, and predicate methods (`prop?`) take the default into account
+- Fix: **ArrayOf** and **HashOf** instances are now really shared for the same subtypes, and **HashOf** accepts anonymous classes
+- Fix: descriptions are no longer evaluated as Ruby code (parentheses or `#{...}` in a description broke or ran code)
+- Fix: `json.load` no longer modifies the given hash or array, and accepts frozen hashes
+- Fix: `override: true` now also replaces a method defined in the class itself before `cprop`
 
 ## [1.0.0] - 2025-03-24
 

data/lib/philosophal/convertor.rb

@@ -87,7 +87,7 @@ module Philosophal
         return obj.to_datetime if obj.respond_to?(:to_datetime)
         return DateTime.new(*obj) if obj.is_a?(Array)
         return DateTime.parse(obj) if obj.is_a?(String)
-        return Time.zone.at(obj).to_datetime if obj.is_a?(Numeric)
+        return Time.at(obj).to_datetime if obj.is_a?(Numeric)
 
         raise Philosophal::TypeError
       end

data/lib/philosophal/loaders/errors.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Philosophal
+  module Loaders
+    class LoadError < StandardError; end
+  end
+end

data/lib/philosophal/loaders/json_loader.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Philosophal
+  module Loaders
+    class JsonLoader
+      def initialize(klass)
+        @klass = klass
+      end
+
+      def load(json)
+        return load_from_hash(json) if json.is_a?(Hash)
+        return load_from_array(json) if json.is_a?(Array)
+
+        raise LoadError, 'invalid json parameter' unless json.is_a?(String)
+
+        first_char = json[0]
+
+        return load_from_json(json) if first_char == '{'
+
+        return load_from_json_collection(json) if first_char == '['
+
+        load_from_path(json)
+      end
+
+      private
+
+      def load_from_array(array)
+        raise LoadError, 'invalid json parameter' if array.find { |hash| !hash.is_a?(Hash) }
+
+        array.map do |hash|
+          load_from_hash(hash)
+        end
+      end
+
+      def load_from_hash(hash)
+        obj = @klass.new
+
+        hash.each do |key, value|
+          setter = setter_from_key(key)
+          next unless obj.respond_to?(setter)
+
+          obj.public_send(setter, value)
+        end
+
+        obj
+      end
+
+      def setter_from_key(key)
+        real_key = @klass.philosophal_properties.json_names_h[key]
+        property = @klass.philosophal_properties[real_key]
+
+        return :"#{property.name}=" if property
+
+        :"#{key}="
+      end
+
+      def load_from_json(str)
+        hash = JSON.parse(str, symbolize_names: true)
+        load_from_hash(hash)
+      end
+
+      def load_from_json_collection(json)
+        array = JSON.parse(json, symbolize_names: true)
+        load_from_array(array)
+      end
+
+      def load_from_path(path)
+        raise LoadError, "no such file #{path}" unless File.exist?(path)
+
+        str = File.read(path)
+        load_from_json(str)
+      end
+    end
+  end
+end

data/lib/philosophal/loaders.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Philosophal
+  module Loaders
+    autoload :JsonLoader, 'philosophal/loaders/json_loader'
+    autoload :LoadError, 'philosophal/loaders/errors'
+  end
+end

data/lib/philosophal/properties/instance_methods.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Philosophal
+  module Properties
+    module InstanceMethods
+      def cprop?(property_name, klass)
+        property = self.class.philosophal_properties.properties_index[property_name.to_sym]
+        return false unless property
+
+        klass = klass.class unless klass.is_a?(Class)
+        property.type == klass
+      end
+
+      def philosophal_inspect(light = false)
+        keys_map = philosophal_inspect_map
+
+        if light
+          keys_map.reject! do |_, v|
+            v.nil? || (v.respond_to?(:empty?) && v.empty?)
+          end
+        end
+
+        keys_str = keys_map.map { |k, v| [k, v.inspect].join(': ') }.join(', ')
+        "#{self.class}:#{format('0x00%x', object_id << 1)} #{keys_str}"
+      end
+      alias cprop_inspect philosophal_inspect
+
+      def philosophal_inspect_map
+        philosophal_values.to_h do |property|
+          [
+            property.name,
+            send(property.name)
+          ]
+        end
+      end
+      alias cprop_inspect_map philosophal_inspect_map
+
+      def philosophal_values
+        self.class.philosophal_properties.properties_index.values
+      end
+
+      def to_json_hash
+        philosophal_values.select(&:json).to_h do |property|
+          [
+            property.json_name,
+            send(property.name)
+          ]
+        end
+      end
+
+      def to_json(*_args)
+        to_json_hash.to_json
+      end
+    end
+  end
+end

data/lib/philosophal/properties/schema.rb

@@ -10,6 +10,14 @@ module Philosophal
         @mutex = Mutex.new
       end
 
+      # Called by #dup: a subclass gets its own index, so its properties do not leak into the parent.
+      def initialize_copy(source)
+        super
+        @properties_index = source.properties_index.dup
+        @mutex = Mutex.new
+        clear_caches
+      end
+
       attr_reader :properties_index
 
       def [](key)
@@ -23,17 +31,38 @@ module Philosophal
       def <<(value)
         @mutex.synchronize do
           @properties_index[value.name] = value
+          clear_caches
         end
 
         self
       end
 
       def immutables
-        @properties_index.select { |_, v| v.immutable }
+        return @immutables if defined?(@immutables)
+
+        @immutables = @properties_index.select { |_, v| v.immutable }
       end
 
       def mutables
-        @properties_index.reject { |_, v| v.immutable }
+        return @mutables if defined?(@mutables)
+
+        @mutables = @properties_index.reject { |_, v| v.immutable }
+      end
+
+      def json_names_h
+        return @json_names_h if defined?(@json_names_h)
+
+        @json_names_h = @properties_index.to_h do |key, property|
+          [property.json_name, key]
+        end
+      end
+
+      private
+
+      def clear_caches
+        %i[@immutables @mutables @json_names_h].each do |cache|
+          remove_instance_variable(cache) if instance_variable_defined?(cache)
+        end
       end
     end
   end

data/lib/philosophal/properties.rb

@@ -3,27 +3,21 @@
 module Philosophal
   module Properties
     autoload :Schema, 'philosophal/properties/schema'
+    autoload :InstanceMethods, 'philosophal/properties/instance_methods'
+    autoload :JSONLoader, 'philosophal/loaders/json_loader'
 
     include Philosophal::Types
 
-    def cprop(name, type, default: nil, transform: nil, immutable: false, description: nil)
-      default.freeze if default && !(default.is_a?(Proc) || default.frozen?)
+    def cprop(name, type, default: nil, transform: nil, immutable: false, description: nil, json: false, override: true)
+      __check_philosophal_options__(name, transform:, immutable:, override:, description:, json:)
 
-      if transform && !(transform.is_a?(Proc) || transform.is_a?(Symbol))
-        raise Philosophal::ArgumentError, "transform param must be a Symbol object or a Proc (#{name})."
-      end
-
-      unless Philosophal::Types::BooleanType::TRUE_FALSE_SET.include?(immutable)
-        raise Philosophal::ArgumentError, 'immutable param must be true or false.'
-      end
-
-      if description
-        raise Philosophal::ArgumentError, 'description param must be a string.' unless description.is_a?(String)
-
-        description.freeze unless description.frozen?
-      end
+      default.freeze unless default.is_a?(Proc)
+      description&.freeze
+      json = json.to_sym if json.is_a?(String)
 
-      property = __philosophal_property_class__.new(name:, type:, default:, transform:, immutable:, description:)
+      property = __philosophal_property_class__.new(
+        name:, type:, default:, transform:, immutable:, description:, json:, override:
+      )
 
       philosophal_properties << property
       __define_philosophal_methods__(property)
@@ -43,7 +37,9 @@ module Philosophal
     def philosophal_descriptions
       return @philosophal_descriptions if defined?(@philosophal_descriptions)
 
-      @philosophal_descriptions = philosophal_properties.properties_index.values.select(&:description).to_h do |property|
+      @philosophal_descriptions = philosophal_properties.properties_index.values
+                                                        .select(&:description)
+                                                        .to_h do |property|
         [
           property.name,
           property.description
@@ -52,6 +48,12 @@ module Philosophal
     end
     alias cprop_descriptions philosophal_descriptions
 
+    def json
+      return @json if defined?(@json)
+
+      @json = Philosophal::Loaders::JsonLoader.new(self)
+    end
+
     private
 
     def __philosophal_property_class__
@@ -64,62 +66,57 @@ module Philosophal
     end
 
     def __philosophal_extension__
-      if defined?(@__philosophal_extension__)
-        @__philosophal_extension__
-      else
-        @__philosophal_extension__ = Module.new do
-          def cprop?(property_name, klass)
-            property = self.class.philosophal_properties.properties_index[property_name.to_sym]
-            return false unless property
-
-            klass = klass.class unless klass.is_a?(Class)
-            property.type == klass
-          end
-
-          def philosophal_inspect(light = false)
-            keys_map = philosophal_inspect_map
-
-            if light
-              keys_map.reject! do |_, v|
-                v.nil? || (v.respond_to?(:empty?) && v.empty?)
-              end
-            end
-
-            keys_str = keys_map.map { |k, v| [k, v.inspect].join(': ') }.join(', ')
-            "#{self.class}:#{format('0x00%x', (object_id << 1))} #{keys_str}"
-          end
-          alias cprop_inspect philosophal_inspect
-
-          def philosophal_inspect_map
-            self.class.philosophal_properties.properties_index.values.to_h do |property|
-              [
-                property.name,
-                send(property.name)
-              ]
-            end
-          end
-          alias cprop_inspect_map philosophal_inspect_map
-        end
+      @__philosophal_extension__ ||= Module.new { include Philosophal::Properties::InstanceMethods }
+    end
+
+    def __generate_philosophal_methods__(new_property)
+      buffer = +''
+
+      new_property.method_generators.each do |method_name, generator|
+        next unless new_property.override? || !method_defined?(method_name)
+
+        __remove_philosophal_own_method__(method_name) if new_property.override?
+        new_property.public_send(generator, buffer)
       end
+
+      # puts buffer
+      return buffer if buffer.empty?
+
+      +"# frozen_string_philosophal: true\n" << buffer
+    end
+
+    # Generated methods live in an included module, so a method defined in the class itself
+    # would hide them: it is removed to let the property override it.
+    def __remove_philosophal_own_method__(method_name)
+      return unless method_defined?(method_name, false) || private_method_defined?(method_name, false)
+
+      remove_method(method_name)
     end
 
-    def __generate_philosophal_methods__(new_property, buffer = +'')
-      buffer << "# frozen_string_philosophal: true\n"
-      if new_property.immutable
-        new_property.generate_immutable_writer_method(buffer)
-      else
-        new_property.generate_writer_method(buffer)
+    def __check_philosophal_options__(name, transform:, immutable:, override:, description:, json:)
+      __check_philosophal_transform_option__(name, transform)
+      __check_philosophal_boolean_option__(:override, override)
+      __check_philosophal_boolean_option__(:immutable, immutable)
+
+      if description && !description.is_a?(String)
+        raise Philosophal::ArgumentError, 'description param must be a string.'
       end
 
-      new_property.generate_reader_method(buffer)
+      return if !json || json == true || json.is_a?(String) || json.is_a?(Symbol)
+
+      raise Philosophal::ArgumentError, 'json param must be true or a String or a Symbol.'
+    end
 
-      new_property.generate_boolean_method(buffer) if new_property.type == Philosophal::Types::BooleanType::Instance
+    def __check_philosophal_transform_option__(name, transform)
+      return if !transform || transform.is_a?(Proc) || transform.is_a?(Symbol)
 
-      new_property.generate_description_method(buffer) if new_property.description
+      raise Philosophal::ArgumentError, "transform param must be a Symbol object or a Proc (#{name})."
+    end
 
-      # puts buffer
+    def __check_philosophal_boolean_option__(option_name, value)
+      return if Philosophal::Types::BooleanType::TRUE_FALSE_SET.include?(value)
 
-      buffer
+      raise Philosophal::ArgumentError, "#{option_name} param must be true or false."
     end
   end
 end

data/lib/philosophal/property.rb

@@ -2,16 +2,24 @@
 
 module Philosophal
   class Property
-    def initialize(name:, type:, default:, transform:, immutable:, description:)
+    def initialize(name:, type:, default:, transform:, immutable:, description:, json:, override:)
       @name = name
       @type = type
       @default = default
       @transform = transform
       @immutable = immutable
       @description = description
+      @json = json
+      @override = override
     end
 
-    attr_reader :name, :type, :default, :transform, :immutable, :description
+    attr_reader :name, :type, :default, :transform, :immutable, :description, :json, :override
+
+    def json_name
+      return @json if @json.is_a?(Symbol)
+
+      @name
+    end
 
     def default?
       @default != nil
@@ -28,61 +36,93 @@ module Philosophal
       @transform != nil
     end
 
+    def override?
+      @override
+    end
+
     def check_conversion(value)
       Philosophal.convert(self, value)
     end
 
-    def generate_writer_method(buffer = +'')
-      buffer <<
-        ' def ' << @name.name << "=(value)\n  " \
-                                 '@' << @name.name << ' = self.class.philosophal_properties[:' <<
-        @name.name <<
-        "].check_conversion(value)\n" \
-        "rescue Philosophal::TypeError => error\n" \
-        "error.set_backtrace(caller(1))\n  raise\n" \
-        "end\n"
-    end
-
-    def generate_immutable_writer_method(buffer = +'')
-      buffer <<
-        ' def ' << @name.name << "=(value)\n  " \
-                                 'raise FrozenError, "can\'t modify frozen variable @' <<
-        @name.name << '" if defined?(@' << @name.name << ")\n" \
-                                                         '@' << @name.name << ' = self.class.philosophal_properties[:' <<
-        @name.name <<
-        "].check_conversion(value).freeze\n" \
-        "rescue Philosophal::TypeError => error\n" \
-        "error.set_backtrace(caller(1))\n  raise\n" \
-        "end\n"
-    end
-
-    def generate_reader_method(buffer = +'')
-      buffer <<
-        ' def ' <<
-        @name.name <<
-        "\n  " \
-        '@' << @name.name << ' || self.class.philosophal_properties[:' <<
-        @name.name <<
-        "].default_value\n" \
-        "end\n"
-    end
-
-    def generate_boolean_method(buffer = +'')
-      buffer <<
-        ' def ' <<
-        @name.name <<
-        "?\n  " \
-        '!!@' << @name.name <<
-        "\nend\n"
-    end
-
-    def generate_description_method(buffer = +'')
-      buffer <<
-        ' def ' <<
-        @name.name <<
-        "_description\n  " \
-        '%(' << @description << ')' \
-        "\nend\n"
+    def method_generators
+      generators = {
+        writer_method_name => immutable ? :generate_immutable_writer_method : :generate_writer_method,
+        reader_method_name => :generate_reader_method
+      }
+      generators[boolean_method_name] = :generate_boolean_method if type == Philosophal::Types::BooleanType::Instance
+      generators[description_method_name] = :generate_description_method if description
+      generators
+    end
+
+    def writer_method_name
+      return @writer_method_name if defined? @writer_method_name
+
+      @writer_method_name = :"#{@name.name}="
+    end
+
+    def generate_writer_method(buffer)
+      buffer << <<~RUBY
+        def #{writer_method_name.name}(value)
+          @#{@name.name} = self.class.philosophal_properties[:#{@name.name}].check_conversion(value)
+        rescue Philosophal::TypeError => error
+          error.set_backtrace(caller(1))
+          raise
+        end
+      RUBY
+    end
+
+    def generate_immutable_writer_method(buffer)
+      buffer << <<~RUBY
+        def #{writer_method_name.name}(value)
+          raise FrozenError, "can't modify frozen variable @#{@name.name}" if defined?(@#{@name.name})
+          @#{@name.name} = self.class.philosophal_properties[:#{@name.name}].check_conversion(value).freeze
+        rescue Philosophal::TypeError => error
+          error.set_backtrace(caller(1))
+          raise
+        end
+      RUBY
+    end
+
+    def reader_method_name
+      @name
+    end
+
+    def generate_reader_method(buffer)
+      buffer << <<~RUBY
+        def #{reader_method_name.name}
+          @#{@name.name}.nil? ? self.class.philosophal_properties[:#{@name.name}].default_value : @#{@name.name}
+        end
+      RUBY
+    end
+
+    def boolean_method_name
+      return @boolean_method_name if defined? @boolean_method_name
+
+      @boolean_method_name = :"#{@name.name}?"
+    end
+
+    def generate_boolean_method(buffer)
+      buffer << <<~RUBY
+        def #{boolean_method_name.name}
+          !!#{reader_method_name.name}
+        end
+      RUBY
+    end
+
+    def description_method_name
+      return @description_method_name if defined? @description_method_name
+
+      @description_method_name = :"#{@name.name}_description"
+    end
+
+    # The description is read from the schema rather than written into the generated code,
+    # so it is never evaluated as Ruby.
+    def generate_description_method(buffer)
+      buffer << <<~RUBY
+        def #{description_method_name.name}
+          self.class.philosophal_properties[:#{@name.name}].description
+        end
+      RUBY
     end
   end
 end

data/lib/philosophal/transform.rb

@@ -3,12 +3,14 @@
 module Philosophal
   class Transform
     def self.make(method, value)
-      case method
-      when Proc
-        method.call(value)
-      else
-        value.send(method)
-      end
+      return method.call(value) if method.is_a?(Proc)
+
+      result = value.send(method)
+      self_method?(method) ? value : result
+    end
+
+    def self.self_method?(method)
+      method.to_s.end_with?('!')
     end
   end
 end

data/lib/philosophal/types/array_of_type.rb

@@ -4,7 +4,7 @@ module Philosophal
   module Types
     class ArrayOfType
       def self.instance(subtype)
-        memorization.fetch(subtype, new(subtype).freeze)
+        memorization[subtype] ||= new(subtype).freeze
       end
 
       def self.memorization
@@ -13,11 +13,12 @@ module Philosophal
         @memorization = {}
       end
 
+      private_class_method :new
+
       attr_reader :subtype
 
       def initialize(subtype)
         @subtype = subtype
-        self.class.memorization[subtype] = self
       end
 
       def ===(array)

data/lib/philosophal/types/hash_of_type.rb

@@ -4,8 +4,7 @@ module Philosophal
   module Types
     class HashOfType
       def self.instance(key_type, value_type)
-        subtype = { key_type:, value_type: }
-        memorization.fetch(Marshal.dump(subtype), new(subtype).freeze)
+        memorization[[key_type, value_type]] ||= new({ key_type:, value_type: }).freeze
       end
 
       def self.memorization
@@ -14,11 +13,12 @@ module Philosophal
         @memorization = {}
       end
 
+      private_class_method :new
+
       attr_reader :subtype
 
       def initialize(subtype)
         @subtype = subtype.freeze
-        self.class.memorization[Marshal.dump(subtype)] = self
       end
 
       def ===(hash)

data/lib/philosophal.rb

@@ -2,8 +2,8 @@
 
 require 'date'
 require 'pathname'
-require 'set'
 require 'time'
+require 'json'
 
 module Philosophal
   autoload :Convertor, 'philosophal/convertor'
@@ -13,30 +13,30 @@ module Philosophal
   autoload :Property, 'philosophal/property'
 
   autoload :Types, 'philosophal/types'
+  autoload :Loaders, 'philosophal/loaders'
 
   autoload :TypeError, 'philosophal/errors/type_error'
   autoload :ArgumentError, 'philosophal/errors/argument_error'
 
   def self.convert(property, value)
-    if property.type === value
-      if property.transform?
-        Transform.make(property.transform, value)
-      else
-        value
-      end
-    else
-      convert_method, subtype = Convertor.convert_method_for(property.type)
-      raise Philosophal::TypeError unless convert_method
+    # nil means "no value": it is neither converted nor transformed, so the reader falls back to the default.
+    return if value.nil?
+
+    converted = property.type === value ? value : convert_to_type(property.type, value) # rubocop:disable Style/CaseEquality
+    return converted unless property.transform?
 
-      converted = if subtype
-                    Convertor.send(convert_method, value, subtype)
-                  else
-                    Convertor.send(convert_method, value)
-                  end
+    Transform.make(property.transform, converted)
+  end
 
-      return converted unless property.transform?
+  def self.convert_to_type(type, value)
+    convert_method, subtype = Convertor.convert_method_for(type)
+    raise Philosophal::TypeError unless convert_method
 
-      Transform.make(property.transform, converted)
+    if subtype
+      Convertor.send(convert_method, value, subtype)
+    else
+      Convertor.send(convert_method, value)
     end
   end
+  private_class_method :convert_to_type
 end

metadata

@@ -1,35 +1,49 @@
 --- !ruby/object:Gem::Specification
 name: philosophal
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.3.0
 platform: ruby
 authors:
 - Maxime Désécot
 autorequire:
-bindir: exe
+bindir: bin
 cert_chain: []
-date: 2026-06-26 00:00:00.000000000 Z
-dependencies: []
-description: Auto convert value on setter method call
+date: 2026-10-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: 'Declare typed attributes with cprop: values are converted, transformed,
+  defaulted or frozen on assignment, with JSON import/export.'
 email:
 - maxime.desecot@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".rubocop.yml"
-- ".ruby-version"
-- ".tool-versions"
 - CHANGELOG.md
 - LICENSE
 - README.md
-- Rakefile
-- VERSION
 - lib/philosophal.rb
 - lib/philosophal/convertor.rb
 - lib/philosophal/errors/argument_error.rb
 - lib/philosophal/errors/type_error.rb
+- lib/philosophal/loaders.rb
+- lib/philosophal/loaders/errors.rb
+- lib/philosophal/loaders/json_loader.rb
 - lib/philosophal/properties.rb
+- lib/philosophal/properties/instance_methods.rb
 - lib/philosophal/properties/schema.rb
 - lib/philosophal/property.rb
 - lib/philosophal/transform.rb
@@ -43,7 +57,7 @@ licenses:
 - GPL-3.0-only
 metadata:
   homepage_uri: https://github.com/RaoH37/philosophal
-  source_code_uri: https://github.com/RaoH37/philosophal
+  bug_tracker_uri: https://github.com/RaoH37/philosophal/issues
   changelog_uri: https://github.com/RaoH37/philosophal/blob/main/CHANGELOG.md
   rubygems_mfa_required: 'true'
 post_install_message:
@@ -54,15 +68,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.1'
+      version: '3.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.27
+rubygems_version: 3.5.22
 signing_key:
 specification_version: 4
-summary: Philosophal setter convertor
+summary: Typed, auto-converting properties for Ruby classes
 test_files: []

data/.rubocop.yml

@@ -1,9 +0,0 @@
-require:
-  - rubocop-minitest
-  - rubocop-packaging
-  - rubocop-performance
-  - rubocop-md
-
-AllCops:
-  TargetRubyVersion: 3.1
-  NewCops: enable

data/.ruby-version

@@ -1 +0,0 @@
-3.1.7

data/.tool-versions

@@ -1 +0,0 @@
-ruby 3.1.7

data/Rakefile

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-require 'bundler/gem_tasks'
-require 'minitest/test_task'
-
-Minitest::TestTask.create
-
-require 'rubocop/rake_task'
-
-RuboCop::RakeTask.new
-
-task default: %i[test rubocop]

data/VERSION

@@ -1 +0,0 @@
-1.1.0