philosophal 1.0.0

data/README.md

@@ -0,0 +1,30 @@
+# Philosophal
+
+If you don't want to manage your parameters' conversation before valuing your objects' instance variables, **Philosophal** is the gem for you ;-)
+
+## Installation
+
+```bash
+gem install philosophal
+```
+
+## Usage
+
+````ruby
+require 'philosophal'
+
+class Person
+  extend Philosophal::Properties
+
+  cprop :first_name, String, transform: :downcase
+  cprop :last_name, String, transform: :upcase
+  cprop :age, Integer
+end
+
+maxime = Person.new
+maxime.first_name = "Maxime"
+maxime.last_name = "Désécot"
+maxime.age = "40" 
+puts maxime.inspect
+#<Person:0x00007da7088eed88 @first_name="maxime", @last_name="DÉSÉCOT", @age=40>
+````

data/Rakefile

@@ -0,0 +1,12 @@
+# 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

@@ -0,0 +1 @@
+1.0.0

data/lib/philosophal/convertor.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module Philosophal
+  class Convertor
+    METHOD_TYPE_MAP = {
+      Symbol => :convert_to_symbol,
+      String => :convert_to_string,
+      Integer => :convert_to_integer,
+      Float => :convert_to_float,
+      Array => :convert_to_array,
+      Hash => :convert_to_hash,
+      Time => :convert_to_time,
+      Date => :convert_to_date,
+      DateTime => :convert_to_date_time,
+      Philosophal::Types::AnyType::Instance => :convert_to_any,
+      Philosophal::Types::BooleanType::Instance => :convert_to_boolean,
+      Philosophal::Types::ArrayOfType => :convert_to_array_of,
+      Philosophal::Types::HashOfType => :convert_to_hash_of,
+      Pathname => :convert_to_pathname
+    }.freeze
+
+    class << self
+      def convert_method_for(type)
+        if type.respond_to?(:subtype)
+          [METHOD_TYPE_MAP[type.class], type.subtype]
+        else
+          METHOD_TYPE_MAP[type]
+        end
+      end
+
+      def convert_to_symbol(obj)
+        raise Philosophal::TypeError unless obj.respond_to?(:to_sym)
+
+        obj.to_sym
+      end
+
+      def convert_to_string(obj)
+        raise Philosophal::TypeError unless obj.respond_to?(:to_s)
+
+        obj.to_s
+      end
+
+      def convert_to_integer(obj)
+        raise Philosophal::TypeError unless obj.respond_to?(:to_i)
+
+        obj.to_i
+      end
+
+      def convert_to_float(obj)
+        raise Philosophal::TypeError unless obj.respond_to?(:to_f)
+
+        obj.to_f
+      end
+
+      def convert_to_array(obj)
+        if obj.respond_to?(:to_a)
+          obj.to_a
+        else
+          [obj]
+        end
+      end
+
+      def convert_to_hash(obj)
+        raise Philosophal::TypeError unless obj.respond_to?(:to_h)
+
+        obj.to_h
+      end
+
+      def convert_to_time(obj)
+        return Time.zone.local(*obj) if obj.is_a?(Array)
+        return Time.zone.parse(obj) if obj.is_a?(String)
+        return Time.zone.at(obj) if obj.is_a?(Numeric)
+
+        raise Philosophal::TypeError
+      end
+
+      def convert_to_date(obj)
+        return obj.to_date if obj.respond_to?(:to_date)
+        return Date.new(*obj) if obj.is_a?(Array)
+        return Date.parse(obj) if obj.is_a?(String)
+        return Time.zone.at(obj).to_date if obj.is_a?(Numeric)
+
+        raise Philosophal::TypeError
+      end
+
+      def convert_to_date_time(obj)
+        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)
+
+        raise Philosophal::TypeError
+      end
+
+      def convert_to_any(obj)
+        obj
+      end
+
+      def convert_to_boolean(obj)
+        if obj.is_a?(Numeric)
+          return true if obj == 1
+          return false if obj.zero?
+
+        elsif obj.is_a?(String)
+          obj_downcase = obj.downcase
+          return true if obj_downcase == 'true'
+          return false if obj_downcase == 'false'
+
+        end
+        raise Philosophal::TypeError
+      end
+
+      def convert_to_pathname(obj)
+        raise Philosophal::TypeError unless obj.respond_to?(:to_s)
+
+        Pathname.new(obj)
+      end
+
+      def convert_to_array_of(obj, subtype)
+        subtype_convert_method = convert_method_for(subtype)
+        raise Philosophal::TypeError unless subtype_convert_method
+
+        convert_to_array(obj).tap do |new_obj|
+          new_obj.map! do |item|
+            send(subtype_convert_method, item)
+          end
+        end
+      end
+
+      def convert_to_hash_of(obj, subtype)
+        key_convert_method = convert_method_for(subtype[:key_type])
+        raise Philosophal::TypeError unless key_convert_method
+
+        value_convert_method = convert_method_for(subtype[:value_type])
+        raise Philosophal::TypeError unless value_convert_method
+
+        convert_to_hash(obj).tap do |new_obj|
+          new_obj.transform_keys! { |key| send(key_convert_method, key) }
+          new_obj.transform_values! { |value| send(value_convert_method, value) }
+        end
+      end
+    end
+  end
+end

data/lib/philosophal/errors/argument_error.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Philosophal
+  class ArgumentError < ArgumentError
+  end
+end

data/lib/philosophal/errors/type_error.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Philosophal
+  class TypeError < TypeError
+  end
+end

data/lib/philosophal/properties/schema.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Philosophal
+  module Properties
+    class Schema
+      include Enumerable
+
+      def initialize(properties_index: {})
+        @properties_index = properties_index
+        @mutex = Mutex.new
+      end
+
+      attr_reader :properties_index
+
+      def [](key)
+        @properties_index[key]
+      end
+
+      def keys
+        @properties_index.keys
+      end
+
+      def <<(value)
+        @mutex.synchronize do
+          @properties_index[value.name] = value
+        end
+
+        self
+      end
+
+      def immutables
+        @properties_index.select { |_, v| v.immutable }
+      end
+
+      def mutables
+        @properties_index.reject { |_, v| v.immutable }
+      end
+    end
+  end
+end

data/lib/philosophal/properties.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Philosophal
+  module Properties
+    autoload :Schema, 'philosophal/properties/schema'
+
+    include Philosophal::Types
+
+    def cprop(name, type, default: nil, transform: nil, immutable: false)
+      default.freeze if default && !(default.is_a?(Proc) || default.frozen?)
+
+      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
+
+      property = __philosophal_property_class__.new(name:, type:, default:, transform:, immutable:)
+
+      philosophal_properties << property
+      __define_philosophal_methods__(property)
+      include(__philosophal_extension__)
+    end
+
+    def philosophal_properties
+      return @philosophal_properties if defined?(@philosophal_properties)
+
+      @philosophal_properties = if defined?(superclass) && superclass.is_a?(Philosophal::Properties)
+                                  superclass.philosophal_properties.dup
+                                else
+                                  Philosophal::Properties::Schema.new
+                                end
+    end
+
+    private
+
+    def __philosophal_property_class__
+      Philosophal::Property
+    end
+
+    def __define_philosophal_methods__(new_property)
+      code =	__generate_philosophal_methods__(new_property)
+      __philosophal_extension__.module_eval(code)
+    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
+      end
+    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)
+      end
+
+      new_property.generate_reader_method(buffer)
+      new_property.generate_boolean_method(buffer) if new_property.type == Philosophal::Types::BooleanType::Instance
+
+      # puts buffer
+
+      buffer
+    end
+  end
+end

data/lib/philosophal/property.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Philosophal
+  class Property
+    def initialize(name:, type:, default:, transform:, immutable:)
+      @name = name
+      @type = type
+      @default = default
+      @transform = transform
+      @immutable = immutable
+    end
+
+    attr_reader :name, :type, :default, :transform, :immutable
+
+    def default?
+      @default != nil
+    end
+
+    def default_value
+      case @default
+      when Proc then @default.call
+      else @default
+      end
+    end
+
+    def transform?
+      @transform != nil
+    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
+  end
+end

data/lib/philosophal/transform.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Philosophal
+  class Transform
+    def self.make(method, value)
+      case method
+      when Proc
+        method.call(value)
+      else
+        value.send(method)
+      end
+    end
+  end
+end

data/lib/philosophal/types/any_type.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Philosophal
+  module Types
+    class AnyType
+      Instance = new.freeze
+
+      def ===(_value)
+        true
+      end
+
+      freeze
+    end
+  end
+end

data/lib/philosophal/types/array_of_type.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Philosophal
+  module Types
+    class ArrayOfType
+      def self.instance(subtype)
+        memorization.fetch(subtype, new(subtype).freeze)
+      end
+
+      def self.memorization
+        return @memorization if defined?(@memorization)
+
+        @memorization = {}
+      end
+
+      attr_reader :subtype
+
+      def initialize(subtype)
+        @subtype = subtype
+        self.class.memorization[subtype] = self
+      end
+
+      def ===(array)
+        array.is_a?(Array) && !array.find { |entry| !entry.is_a?(@subtype) }
+      end
+    end
+  end
+end

data/lib/philosophal/types/boolean_type.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Philosophal
+  module Types
+    class BooleanType
+      Instance = new.freeze
+
+      TRUE_FALSE_SET = Set[true, false]
+
+      def ===(value)
+        TRUE_FALSE_SET.include?(value)
+      end
+
+      freeze
+    end
+  end
+end

data/lib/philosophal/types/hash_of_type.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+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)
+      end
+
+      def self.memorization
+        return @memorization if defined?(@memorization)
+
+        @memorization = {}
+      end
+
+      attr_reader :subtype
+
+      def initialize(subtype)
+        @subtype = subtype.freeze
+        self.class.memorization[Marshal.dump(subtype)] = self
+      end
+
+      def ===(hash)
+        hash.is_a?(Hash) &&
+          !hash.keys.find { |key| !key.is_a?(@subtype[:key_type]) } &&
+          !hash.values.find { |value| !value.is_a?(@subtype[:value_type]) }
+      end
+    end
+  end
+end

data/lib/philosophal/types.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Philosophal
+  module Types
+    autoload :AnyType, 'philosophal/types/any_type'
+    autoload :BooleanType, 'philosophal/types/boolean_type'
+    autoload :ArrayOfType, 'philosophal/types/array_of_type'
+    autoload :HashOfType, 'philosophal/types/hash_of_type'
+
+    def _Any
+      AnyType::Instance
+    end
+
+    def _Boolean
+      BooleanType::Instance
+    end
+
+    def _ArrayOf(subtype)
+      ArrayOfType.instance(subtype)
+    end
+
+    def _HashOf(key_type, value_type)
+      HashOfType.instance(key_type, value_type)
+    end
+  end
+end

data/lib/philosophal.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'date'
+require 'pathname'
+require 'set'
+require 'time'
+
+module Philosophal
+  autoload :Convertor, 'philosophal/convertor'
+  autoload :Transform, 'philosophal/transform'
+
+  autoload :Properties, 'philosophal/properties'
+  autoload :Property, 'philosophal/property'
+
+  autoload :Types, 'philosophal/types'
+
+  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
+
+      converted = if subtype
+                    Convertor.send(convert_method, value, subtype)
+                  else
+                    Convertor.send(convert_method, value)
+                  end
+
+      return converted unless property.transform?
+
+      Transform.make(property.transform, converted)
+    end
+  end
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification
+name: philosophal
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Maxime Désécot
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2025-03-24 00:00:00.000000000 Z
+dependencies: []
+description: Auto convert value on setter method call
+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/properties.rb
+- lib/philosophal/properties/schema.rb
+- lib/philosophal/property.rb
+- lib/philosophal/transform.rb
+- lib/philosophal/types.rb
+- lib/philosophal/types/any_type.rb
+- lib/philosophal/types/array_of_type.rb
+- lib/philosophal/types/boolean_type.rb
+- lib/philosophal/types/hash_of_type.rb
+homepage: https://github.com/RaoH37/philosophal
+licenses:
+- GPL-3.0-only
+metadata:
+  homepage_uri: https://github.com/RaoH37/philosophal
+  source_code_uri: https://github.com/RaoH37/philosophal
+  changelog_uri: https://github.com/RaoH37/philosophal/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+post_install_message:
+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.3.27
+signing_key:
+specification_version: 4
+summary: Philosophal setter convertor
+test_files: []