low_type 1.0.0 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5872bc6f373425ddfc4342d0421dd09e4e3bd6a5e7e0b4d3ba1d1c19cd077a5c
-  data.tar.gz: 9b5543ba7bded1c2a043966376956316624408a101f2b30ec9a6b16d07976973
+  metadata.gz: 9a921b130ff71b7911409536acb53ad6ef7abebf91d789ce7ce27fde24b90e95
+  data.tar.gz: 9138f98a23846c1bb2474d2bb7b163dd0b0575e7c5911dd4b7ba05fc9deacb48
 SHA512:
-  metadata.gz: c3a31c05871cc0d4b5fde6fca3c03c94fbc7e2ccc2696eb7eab401f8817e0b0a1abbd0bf4aa91d72454a61c60265b22ba9997148161f7d3e796d2e9c790e9c81
-  data.tar.gz: 3629f1ac45bc9cbfce9979f85e933bb3b12b731747b714fb8eba6b7399cf139ac6098eb37667b97b624e95eda4e02c104ce9d7cd2b6013ea3fbb639e1e4a0125
+  metadata.gz: a440d93c18f7e444293f6987b5655644856d15ebba9a32b6d01818e9546339d48d8b48f5b09023e3039271195c790ce6ec713ca2b05498202cfd45d628c12e2a
+  data.tar.gz: '039ca399f75d3ee60be9c73399dfb15cadaf62d200254cdc1c873130b595c7715917eda4fa2e926e986c66817e6de972701c5b21cdc2e68ec282da71d040b46a'

data/lib/adapters/sinatra_adapter.rb

@@ -5,7 +5,7 @@ require 'prism'
 require_relative '../interfaces/adapter_interface'
 require_relative '../proxies/file_proxy'
 require_relative '../proxies/return_proxy'
-require_relative '../error_types'
+require_relative '../types/error_types'
 
 module LowType
   module Adapter
@@ -27,7 +27,7 @@ module LowType
 
           pattern = arguments_node.arguments.first.content
 
-          line = Parser.line_number(node: method_call)
+          line = FileParser.line_number(node: method_call)
           file = FileProxy.new(path: @file_path, line:, scope: "#{@klass}##{method_call.name}")
           next unless (return_proxy = return_proxy(method_node: method_call, pattern:, file:))
 
@@ -38,7 +38,7 @@ module LowType
       end
 
       def return_proxy(method_node:, pattern:, file:)
-        return_type = Parser.return_type(method_node:)
+        return_type = FileParser.return_type(method_node:)
         return nil if return_type.nil?
 
         # Not a security risk because the code comes from a trusted source; the file that did the include. Does the file trust itself?

data/lib/factories/proxy_factory.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
 require_relative '../proxies/return_proxy'
-require_relative '../parser'
+require_relative '../file_parser'
 require_relative '../type_expression'
 
 module LowType
   class ProxyFactory
     class << self
       def return_proxy(method_node:, file:)
-        return_type = Parser.return_type(method_node:)
+        return_type = FileParser.return_type(method_node:)
         return nil if return_type.nil?
 
         # Not a security risk because the code comes from a trusted source; the file that did the include. Does the file trust itself?

data/lib/{parser.rb → file_parser.rb}

@@ -3,26 +3,26 @@
 require 'prism'
 
 module LowType
-  class Parser
-    attr_reader :parent_map, :instance_methods, :class_methods, :private_start_line
+  class FileParser
+    attr_reader :parent_map, :instance_methods, :class_methods, :line_numbers
 
-    def initialize(file_path:)
+    def initialize(klass:, file_path:)
       @root_node = Prism.parse_file(file_path).value
 
       parent_mapper = ParentMapper.new
       parent_mapper.visit(@root_node)
       @parent_map = parent_mapper.parent_map
 
-      method_visitor = MethodDefVisitor.new(@parent_map)
+      method_visitor = MethodDefVisitor.new(root_node: @root_node, parent_map:, klass:)
       @root_node.accept(method_visitor)
 
       @instance_methods = method_visitor.instance_methods
       @class_methods = method_visitor.class_methods
-      @private_start_line = method_visitor.private_start_line
+      @line_numbers = method_visitor.line_numbers
     end
 
     def method_calls(method_names:)
-      block_visitor = MethodCallVisitor.new(parent_map: @parent_map, method_names:)
+      block_visitor = MethodCallVisitor.new(parent_map:, method_names:)
       @root_node.accept(block_visitor)
       block_visitor.method_calls
     end
@@ -54,14 +54,15 @@ module LowType
   end
 
   class MethodDefVisitor < Prism::Visitor
-    attr_reader :class_methods, :instance_methods, :private_start_line
+    attr_reader :class_methods, :instance_methods, :line_numbers
 
-    def initialize(parent_map)
+    def initialize(root_node:, parent_map:, klass:)
       @parent_map = parent_map
+      @klass = klass
 
       @instance_methods = []
       @class_methods = []
-      @private_start_line = nil
+      @line_numbers = { class_start: 0, class_end: root_node.end_line }
     end
 
     def visit_def_node(node)
@@ -75,7 +76,23 @@ module LowType
     end
 
     def visit_call_node(node)
-      @private_start_line = node.start_line if node.name == :private && node.respond_to?(:start_line)
+      start_line = node.name == :private && node.respond_to?(:start_line) && node.start_line || nil
+      class_start = @line_numbers[:class_start]
+      class_end = @line_numbers[:class_end]
+
+      if start_line && class_start && class_end && start_line > class_start && start_line < class_end
+        @line_numbers[:private_start] = node.start_line
+      end
+
+      super
+    end
+
+    def visit_class_node(node)
+      if node.name == @klass.to_s.to_sym
+        @line_numbers = { class_start: node.class_keyword_loc.start_line, class_end: node.end_keyword_loc.end_line }
+      end
+
+      super
     end
 
     private

data/lib/local_types.rb

@@ -2,27 +2,32 @@
 
 require_relative 'proxies/file_proxy'
 require_relative 'proxies/local_proxy'
+require_relative 'types/error_types'
 require_relative 'type_expression'
 require_relative 'value_expression'
 
-module LocalTypes
-  def type(type_expression)
-    value = type_expression.default_value
+module LowType
+  module LocalTypes
+    def type(type_expression)
+      value = type_expression.default_value
 
-    last_caller = caller_locations(1, 1).first
-    file = LowType::FileProxy.new(path: last_caller.path, line: last_caller.lineno, scope: 'local type')
-    proxy = LowType::LocalProxy.new(type_expression:, name: self, file:)
+      last_caller = caller_locations(1, 1).first
+      file = FileProxy.new(path: last_caller.path, line: last_caller.lineno, scope: 'local type')
+      proxy = LocalProxy.new(type_expression:, name: self, file:)
 
-    type_expression.validate!(value:, proxy:)
+      type_expression.validate!(value:, proxy:)
 
-    return value.value if value.is_a?(ValueExpression)
+      return value.value if value.is_a?(ValueExpression)
 
-    value
-  end
-  alias low_type type
+      value
+    rescue NoMethodError
+      raise ConfigError, "Invalid type expression, likely because you didn't add 'using LowType::Syntax'"
+    end
+    alias low_type type
 
-  def value(type)
-    LowType.value(type:)
+    def value(type)
+      LowType.value(type:)
+    end
+    alias low_value value
   end
-  alias low_value value
 end

data/lib/low_type.rb

@@ -1,32 +1,31 @@
 # frozen_string_literal: true
 
 require_relative 'adapters/adapter_loader'
-require_relative 'basic_types'
+require_relative 'types/complex_types'
 require_relative 'instance_types'
 require_relative 'local_types'
 require_relative 'redefiner'
-require_relative 'subclasses'
+require_relative 'syntax'
 require_relative 'type_expression'
 require_relative 'value_expression'
 
-# Include this module into your class to define and check types.
 module LowType
   # We do as much as possible on class load rather than on instantiation to be thread-safe and efficient.
-  def self.included(klass) # rubocop:disable Metrics/AbcSize
+  def self.included(klass)
     class << klass
       def low_methods
         @low_methods ||= {}
       end
     end
 
-    file_path = LowType.file_path(klass:)
-    parser = LowType::Parser.new(file_path:)
-    private_start_line = parser.private_start_line
+    file_path = LowType.file_path
+    parser = FileParser.new(klass:, file_path:)
+    line_numbers = parser.line_numbers
 
     klass.extend InstanceTypes
     klass.include LocalTypes
-    klass.prepend LowType::Redefiner.redefine(method_nodes: parser.instance_methods, klass:, private_start_line:, file_path:)
-    klass.singleton_class.prepend LowType::Redefiner.redefine(method_nodes: parser.class_methods, klass:, private_start_line:, file_path:)
+    klass.prepend LowType::Redefiner.redefine(method_nodes: parser.instance_methods, klass:, line_numbers:, file_path:)
+    klass.singleton_class.prepend LowType::Redefiner.redefine(method_nodes: parser.class_methods, klass:, line_numbers:, file_path:)
 
     if (adapter = Adapter::Loader.load(klass:, parser:, file_path:))
       adapter.process
@@ -48,11 +47,9 @@ module LowType
 
     # Internal API.
 
-    def file_path(klass:)
-      # Remove module namespaces from class.
-      class_name = klass.to_s.split(':').last
-      # The first class found regardless of namespace will be the class that did the include.
-      caller.find { |callee| callee.end_with?("<class:#{class_name}>'") }.split(':').first
+    def file_path
+      includer_file = caller.find { |callee| callee.end_with?("in 'Module#include'") || callee.end_with?("in 'include'") }
+      includer_file.split(':').first
     end
 
     # TODO: Unit test.

data/lib/proxies/local_proxy.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require_relative '../interfaces/error_interface'
-require_relative '../error_types'
+require_relative '../types/error_types'
 
 module LowType
   class LocalProxy < ErrorInterface

data/lib/proxies/param_proxy.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require_relative '../interfaces/error_interface'
-require_relative '../error_types'
+require_relative '../types/error_types'
 
 module LowType
   class ParamProxy < ErrorInterface

data/lib/proxies/return_proxy.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require_relative '../interfaces/error_interface'
-require_relative '../error_types'
+require_relative '../types/error_types'
 
 module LowType
   class ReturnProxy < ErrorInterface

data/lib/redefiner.rb

@@ -4,58 +4,80 @@ require_relative 'factories/proxy_factory'
 require_relative 'proxies/file_proxy'
 require_relative 'proxies/method_proxy'
 require_relative 'proxies/param_proxy'
+require_relative 'syntax'
 require_relative 'type_expression'
 
 module LowType
   # Redefine methods to have their arguments and return values type checked.
   class Redefiner
+    using Syntax
+
     class << self
-      def redefine(method_nodes:, klass:, private_start_line:, file_path:) # rubocop:disable Metrics
+      def redefine(method_nodes:, klass:, line_numbers:, file_path:)
+        create_proxies(method_nodes:, klass:, file_path:)
+        define_methods(method_nodes:, line_numbers:)
+      end
+
+      private
+
+      def create_proxies(method_nodes:, klass:, file_path:)
+        method_nodes.each do |method_node|
+          name = method_node.name
+          line = FileParser.line_number(node: method_node)
+          file = FileProxy.new(path: file_path, line:, scope: "#{klass}##{name}")
+          params = param_proxies(method_node:, file:)
+          return_proxy = ProxyFactory.return_proxy(method_node:, file:)
+
+          klass.low_methods[name] = MethodProxy.new(name:, params:, return_proxy:)
+        end
+      end
+
+      def define_methods(method_nodes:, line_numbers:) # rubocop:disable Metrics
+        class_start = line_numbers[:class_start]
+        class_end = line_numbers[:class_end]
+        private_start = line_numbers[:private_start]
+
         Module.new do
           method_nodes.each do |method_node|
-            name = method_node.name
-            line = Parser.line_number(node: method_node)
-            file = FileProxy.new(path: file_path, line:, scope: "#{klass}##{method_node.name}")
-            params = Redefiner.params_with_type_expressions(method_node:, file:)
-            return_proxy = ProxyFactory.return_proxy(method_node:, file:)
+            method_start = method_node.start_line
+            next unless method_start > class_start && method_node.end_line <= class_end
 
-            klass.low_methods[name] = MethodProxy.new(name:, params:, return_proxy:)
+            name = method_node.name
 
             define_method(name) do |*args, **kwargs|
-              klass.low_methods[name].params.each do |param_proxy|
+              method_proxy = instance_of?(Class) ? low_methods[name] : self.class.low_methods[name] || Object.low_methods[name]
+
+              method_proxy.params.each do |param_proxy|
                 # Get argument value or default value.
                 value = param_proxy.position ? args[param_proxy.position] : kwargs[param_proxy.name]
                 if value.nil? && param_proxy.type_expression.default_value != :LOW_TYPE_UNDEFINED
                   value = param_proxy.type_expression.default_value
                 end
-                # Validate argument type.
+
                 param_proxy.type_expression.validate!(value:, proxy: param_proxy)
-                # Handle value(type) special case.
                 value = value.value if value.is_a?(ValueExpression)
-                # Redefine argument value.
                 param_proxy.position ? args[param_proxy.position] = value : kwargs[param_proxy.name] = value
               end
 
-              if return_proxy
+              if (return_proxy = method_proxy.return_proxy)
                 return_value = super(*args, **kwargs)
-                return_proxy.type_expression.validate!(value: return_value, proxy: klass.low_methods[name].return_proxy)
+                return_proxy.type_expression.validate!(value: return_value, proxy: return_proxy)
                 return return_value
               end
 
               super(*args, **kwargs)
             end
 
-            private name if private_start_line && method_node.start_line > private_start_line
+            private name if private_start && method_start > private_start
           end
         end
       end
 
-      def params_with_type_expressions(method_node:, file:)
+      def param_proxies(method_node:, file:)
         return [] if method_node.parameters.nil?
 
         params = method_node.parameters.slice
-        # Not a security risk because the code comes from a trusted source; the file that did the include. Does the file trust itself?
-        proxy_method = eval("-> (#{params}) {}", binding, __FILE__, __LINE__) # rubocop:disable Security/Eval
+        proxy_method = proxy_method(method_node:)
         required_args, required_kwargs = required_args(proxy_method:)
 
         # Not a security risk because the code comes from a trusted source; the file that did the include. Does the file trust itself?
@@ -87,7 +109,11 @@ module LowType
         raise ArgumentError, "Incorrect param syntax: #{e.message}"
       end
 
-      private
+      def proxy_method(method_node:)
+        params = method_node.parameters.slice
+        # Not a security risk because the code comes from a trusted source; the file that did the include. Does the file trust itself?
+        eval("-> (#{params}) {}", binding, __FILE__, __LINE__) # rubocop:disable Security/Eval
+      end
 
       def required_args(proxy_method:)
         required_args = []

data/lib/{subclasses.rb → syntax.rb}

@@ -1,42 +1,26 @@
-module LowType
-  # Scoped to the class that includes LowType module.
-  class Array < ::Array
-    def self.[](*types)
-      return LowType::TypeExpression.new(type: [*types]) if types.all? { |type| LowType.type?(type) }
-      super
-    end
+# frozen_string_literal: true
 
-    def self.===(other)
-      return true if other == ::Array
-      super
-    end
-
-    def ==(other)
-      return true if other.class == ::Array
-      super
-    end
-  end
+module LowType
+  module Syntax
+    refine Array.singleton_class do
+      def [](*types)
+        return LowType::TypeExpression.new(type: [*types]) if types.all? { |type| LowType.type?(type) }
 
-  # Scoped to the class that includes LowType module.
-  class Hash < ::Hash
-    def self.[](type)
-      return LowType::TypeExpression.new(type:) if LowType.type?(type)
-      super
+        super
+      end
     end
 
-    def self.===(other)
-      return true if other == ::Hash
-      super
-    end
+    refine Hash.singleton_class do
+      def [](type)
+        return LowType::TypeExpression.new(type:) if LowType.type?(type)
 
-    def ==(other)
-      return true if other.class == ::Hash
-      super
+        super
+      end
     end
   end
 end
 
-# Scoped to the top-level for method type expressions to work. Could we bind/unbind? Yes. Should we? Probably not.
+# Refine doesn't support inheritence.
 class Object
   # For "Type | [type_expression/type/value]" situations, redirecting to or generating a type expression from types.
   # "|" is not defined on Object class and this is the most compute-efficient way to achieve our goal (world peace).

data/lib/type_expression.rb

@@ -57,9 +57,9 @@ module LowType
 
     def valid_types
       types = @types.map do |type|
-        # Remove 'LowType::' namespaces in subtypes.
+        # Remove 'LowType::' namespace in subtypes.
         if type.is_a?(::Array)
-          '[' + type.map { |subtype| subtype.to_s.delete_prefix('LowType::') }.join(', ') + ']'
+          "[#{type.map { |subtype| subtype.to_s.delete_prefix('LowType::') }.join(', ')}]"
         else
           type.inspect.to_s.delete_prefix('LowType::')
         end

data/lib/{error_types.rb → types/error_types.rb}

@@ -5,4 +5,5 @@ module LowType
   class LocalTypeError < TypeError; end
   class ReturnTypeError < TypeError; end
   class AllowedTypeError < TypeError; end
+  class ConfigError < TypeError; end
 end

data/lib/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: low_type
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.2
 platform: ruby
 authors:
 - maedi
@@ -19,23 +19,23 @@ extra_rdoc_files: []
 files:
 - lib/adapters/adapter_loader.rb
 - lib/adapters/sinatra_adapter.rb
-- lib/basic_types.rb
-- lib/error_types.rb
 - lib/factories/proxy_factory.rb
+- lib/file_parser.rb
 - lib/instance_types.rb
 - lib/interfaces/adapter_interface.rb
 - lib/interfaces/error_interface.rb
 - lib/local_types.rb
 - lib/low_type.rb
-- lib/parser.rb
 - lib/proxies/file_proxy.rb
 - lib/proxies/local_proxy.rb
 - lib/proxies/method_proxy.rb
 - lib/proxies/param_proxy.rb
 - lib/proxies/return_proxy.rb
 - lib/redefiner.rb
-- lib/subclasses.rb
+- lib/syntax.rb
 - lib/type_expression.rb
+- lib/types/complex_types.rb
+- lib/types/error_types.rb
 - lib/value_expression.rb
 - lib/version.rb
 homepage: https://codeberg.org/low_ruby/low_type