low_type 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 849b5a1d0d8d4ec70dda7366f9e72a991aa71ce72631495f66c78e3bb03b8de3
+  data.tar.gz: 4e5f71133ec37642bee7ef092103926d9b673e6ac3d2f0c621bee69e25b4953c
+SHA512:
+  metadata.gz: dc9e6b031328b7c398b04cb15ebeb9c347c3b4ff6c49a6e64570dbfdfb2b95b8facfde45bbb07f63c285631280629c2d5b8674e7709505ebac8342fd81a539ed
+  data.tar.gz: cde6c6557d6b47c1e35b6b6216fb939e85f778439483d5c493a21d64cade1d3f6b4bca5c689d0def331a5fb2f0da7f6ee7c497fd974ece7224af72dbb616970c

data/lib/low_type.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require_relative 'type_expression'
+
+module LowType
+  class InvalidTypeError < StandardError; end;
+  class RequiredValueError < StandardError; end;
+
+  # We do as much as possible on class load rather than on instantiation to be thread-safe and efficient.
+  def self.included(base)
+    class << base
+      def low_params
+        @low_params ||= {}
+      end
+
+      def type(expression)
+        # TODO: Runtime type expression for the supplied variable.
+      end
+      alias_method :low_type, :type
+
+      def value(expression)
+        # TODO: Cancel out a type expression.
+      end
+      alias_method :low_value, :value
+    end
+
+    base.prepend LowType.redefine_methods(file_path: LowType.file_path(klass: base), klass: base)
+  end
+
+  def self.redefine_methods(file_path:, klass:)
+    Module.new do
+      # TODO: Use an AST.
+      File.readlines(file_path).each do |file_line|
+        method_line = file_line.strip
+        next unless method_line.start_with?('def ') && method_line.include?('(')
+
+        method_name, args = method_line.delete_prefix('def ').split(/[()]/)
+        method_name = method_name.to_sym
+
+        proxy_method = eval("-> (#{args}) {}")
+        required_args, required_kwargs = LowType.required_args(proxy_method)
+
+        klass.low_params[method_name] = LowType.type_expressions_from_params(proxy_method, args, required_args, required_kwargs)
+        
+        define_method(method_name) do |*args, **kwargs|
+          klass.low_params[method_name].each do |param_proxy|
+            arg = param_proxy.position ? args[param_proxy.position] : kwargs[param_proxy.name]
+            arg = param_proxy.type_expression.default_value if arg.nil? && param_proxy.type_expression.default_value != :LOW_TYPE_UNDEFINED
+            param_proxy.type_expression.validate!(arg:, name: param_proxy.name)
+            param_proxy.position ? args[param_proxy.position] = arg : kwargs[param_proxy.name] = arg
+          end
+
+          super(*args, **kwargs)
+        end
+      end
+    end
+  end
+
+  class << self
+    def methods(klass)
+      klass.public_instance_methods(false) + klass.protected_instance_methods(false) + klass.private_instance_methods(false)
+    end
+
+    def file_path(klass:)
+      caller.find { |callee| callee.end_with?("<class:#{klass}>'") }.split(':').first
+    end
+
+    def type?(expression)
+      expression.respond_to?(:new) || expression == Integer
+    end
+
+    def value?(expression)
+      !expression.respond_to?(:new) && expression != Integer
+    end
+
+    def required_args(proxy_method)
+      required_args = []
+      required_kwargs = {}
+
+      proxy_method.parameters.each do |param|
+        param_type, param_name = param
+
+        case param_type
+        when :req
+          required_args << nil
+        when :keyreq
+          required_kwargs[param_name] = nil
+        end
+      end
+
+      [required_args, required_kwargs]
+    end
+
+    def type_expressions_from_params(proxy_method, args, required_args, required_kwargs)
+      typed_method = eval(
+        <<~RUBY
+          -> (#{args}) {
+            param_proxies = []
+
+            proxy_method.parameters.each_with_index do |param, position|
+              type, name = param
+              position = nil unless [:opt, :req, :rest].include?(type)
+
+              expression = binding.local_variable_get(name)
+
+              if expression.class == TypeExpression
+                param_proxies << ParamProxy.new(type_expression: expression, name:, type:, position:)
+              elsif ::LowType.type?(expression)
+                param_proxies << ParamProxy.new(type_expression: TypeExpression.new(type: expression), name:, type:, position:)
+              end
+            end
+
+            param_proxies
+          }
+        RUBY
+      )
+
+      # Call method with only its required args to evaluate type expressions (which are stored as default values).
+      typed_method.call(*required_args, **required_kwargs)
+    end
+  end
+
+  class ParamProxy
+    attr_reader :type_expression, :name, :type, :position
+
+    def initialize(type_expression:, name:, type:, position: nil)
+      @type_expression = type_expression
+      @name = name
+      @type = type
+      @position = position
+    end
+  end
+
+  class ValueExpression; end
+
+  class Boolean; end
+  class KeyValue; end
+end

data/lib/type_expression.rb

@@ -0,0 +1,51 @@
+module LowType
+  class TypeExpression
+    attr_reader :type, :default_value
+
+    def initialize(type:)
+      @types = [type]
+      @default_value = :LOW_TYPE_UNDEFINED
+    end
+
+    def |(expression)
+      if expression.class == ::LowType::TypeExpression
+        @types = @types + expression.types
+        @default_value = expression.default_value
+      elsif ::LowType.value?(expression)
+        @default_value = expression
+      else
+        @types << expression
+      end
+
+      self
+    end
+
+    def required?
+      @default_value == :LOW_TYPE_UNDEFINED
+    end
+
+    def validate!(arg:, name:)
+      if arg.nil? && required?
+        raise ::LowType::RequiredValueError, "Missing value of required type [#{@types.join(',')}] for '#{name}'"
+      end
+
+      raise ::LowType::InvalidTypeError, "Invalid type '#{arg.class}' for '#{name}'" unless @types.include?(arg.class)
+    end
+  end
+end
+
+class Object
+  class << self
+    # "|" is not defined on Object class and this is the most compute-efficient way to achieve our goal (world peace).
+    # "|" bitwise operator on Integer is not defined when the receiver is an Integer class, so we are not in conflict.
+    def |(expression)
+      if expression.class == ::LowType::TypeExpression
+        expression | self
+        expression
+      else
+        type_expression = ::LowType::TypeExpression.new(type: self)
+        type_expression | expression        
+      end
+    end
+  end
+end

data/lib/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module LowType
+  VERSION = '0.1.0'
+end

metadata

@@ -0,0 +1,48 @@
+--- !ruby/object:Gem::Specification
+name: low_type
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- maedi
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2025-10-10 00:00:00.000000000 Z
+dependencies: []
+description: An elegant and simple way to define types in Ruby, only when you need
+  them.
+email:
+- maediprichard@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/low_type.rb
+- lib/type_expression.rb
+- lib/version.rb
+homepage: https://codeberg.org/low_ruby/low_type
+licenses: []
+metadata:
+  homepage_uri: https://codeberg.org/low_ruby/low_type
+  source_code_uri: https://codeberg.org/low_ruby/low_type/src/branch/main
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.9
+signing_key:
+specification_version: 4
+summary: An elegant way to define types in Ruby
+test_files: []