philosophal 1.2.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1df7f3c754eeef6776d0e3a18bcfdb81124e413187beb2f580dd550cbdcd046e
-  data.tar.gz: 03ed60c26e12f8225145e6f00a138da84e3d1aa11ffd1ab1be878df0032e6896
+  metadata.gz: d1bb80908d227d997cf25e816e00335f9c61328aa4eb285ee7c51632adfcc9cb
+  data.tar.gz: 56ca323ff898cb43b8604850e0ea94cd5b323c236d365a70ad8d36e9321bd01f
 SHA512:
-  metadata.gz: ab3fd3bf30dbaba5d2936979b832b2f9a715b7dbab19eba5d08c7feb4e84aa5affd41247b294ffc7ff9a4c054dcaba932ba2cb98d9c8699b5825d1dbad4c0a9b
-  data.tar.gz: 2b372e50b9bcf123531cdc0df806061893e86a3ddc70eddc2cc47731a017cff18dea606aea8c3477c2d8f2adf1faaa051c3728ad8645b166a0c5c120e583f951
+  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/json_loader.rb

@@ -27,7 +27,7 @@ module Philosophal
       def load_from_array(array)
         raise LoadError, 'invalid json parameter' if array.find { |hash| !hash.is_a?(Hash) }
 
-        array.map! do |hash|
+        array.map do |hash|
           load_from_hash(hash)
         end
       end
@@ -35,11 +35,11 @@ module Philosophal
       def load_from_hash(hash)
         obj = @klass.new
 
-        hash.each_key do |key|
+        hash.each do |key, value|
           setter = setter_from_key(key)
           next unless obj.respond_to?(setter)
 
-          obj.public_send(setter, hash.delete(key))
+          obj.public_send(setter, value)
         end
 
         obj

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,6 +31,7 @@ module Philosophal
       def <<(value)
         @mutex.synchronize do
           @properties_index[value.name] = value
+          clear_caches
         end
 
         self
@@ -47,6 +56,14 @@ module Philosophal
           [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
 end

data/lib/philosophal/properties.rb

@@ -3,36 +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, json: false)
-      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)
 
-      if json
-        unless json.is_a?(TrueClass) || json.is_a?(String) || json.is_a?(Symbol)
-          raise Philosophal::ArgumentError, 'json param must be true or a String or a Symbol.'
-        end
-
-        json = json.to_sym if json.is_a?(String)
-      end
-
-      property = __philosophal_property_class__.new(name:, type:, default:, transform:, immutable:, description:, json:)
+      property = __philosophal_property_class__.new(
+        name:, type:, default:, transform:, immutable:, description:, json:, override:
+      )
 
       philosophal_properties << property
       __define_philosophal_methods__(property)
@@ -81,79 +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
-            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
+      @__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,7 +2,7 @@
 
 module Philosophal
   class Property
-    def initialize(name:, type:, default:, transform:, immutable:, description:, json:)
+    def initialize(name:, type:, default:, transform:, immutable:, description:, json:, override:)
       @name = name
       @type = type
       @default = default
@@ -10,9 +10,10 @@ module Philosophal
       @immutable = immutable
       @description = description
       @json = json
+      @override = override
     end
 
-    attr_reader :name, :type, :default, :transform, :immutable, :description, :json
+    attr_reader :name, :type, :default, :transform, :immutable, :description, :json, :override
 
     def json_name
       return @json if @json.is_a?(Symbol)
@@ -35,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,7 +2,6 @@
 
 require 'date'
 require 'pathname'
-require 'set'
 require 'time'
 require 'json'
 
@@ -20,25 +19,24 @@ module Philosophal
   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,30 +1,40 @@
 --- !ruby/object:Gem::Specification
 name: philosophal
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.3.0
 platform: ruby
 authors:
 - Maxime Désécot
 autorequire:
-bindir: exe
+bindir: bin
 cert_chain: []
-date: 2026-06-29 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
@@ -33,6 +43,7 @@ files:
 - 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
@@ -46,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:
@@ -57,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,12 +0,0 @@
-require:
-  - rubocop-minitest
-  - rubocop-packaging
-  - rubocop-performance
-  - rubocop-md
-
-AllCops:
-  TargetRubyVersion: 3.1
-  NewCops: enable
-
-Style/Documentation:
-  Enabled: false

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.2.0