low_type 1.0.8 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6e3e1dca0d960082a4de505f3422e00c648f660306c22d24db65590db0543f5e
-  data.tar.gz: a87156e750aee311a9afb2a95166a9d00f99a744c05fc1dac0d9ab7120882760
+  metadata.gz: d8dae7f03ed51a1acea72d53deec50af0722e9c57ac8baab72297420bae36f4b
+  data.tar.gz: d7de0927fb139ac7d2b934c01f464224bb30fe2fbba6ca8b62a789955561e602
 SHA512:
-  metadata.gz: f8e3054ab427c0635aa27f78ae966e3a90c9f78ec660651d6025956ddc83582a1b46f66268e7a335d8ff72ed87bf92a09672a38509067d42d3b79253a97e8d49
-  data.tar.gz: 4698ae94c57a2de408ba085029f18b1bc100375972f3f253294dfcef71741d959da1db6773544f4bf55133d5a95d3e2eee44f274f167c503e7f462489e247153
+  metadata.gz: f4a91869b8c041091cd2dcadfb5ff931883041f7d57319b6cfb60b8ef7c1607924d81b93fc1a936724a3d577e904ed1d76c5bb03c89d6bf872e6446f0490f52e
+  data.tar.gz: d42d49968af57b0122e76449d01a5ed118bb4394d28fe42a6a9ec9095f6900ec02940e237e75fe3c1c4417b307c0b85497193a492b721e3c139902a15d92be7b

data/lib/factories/type_factory.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module LowType
+  class TypeFactory
+    class << self
+      def complex_type(parent_type)
+        Class.new(parent_type) do
+          def self.match?(value:)
+            return true if value.instance_of?(self.class) || value.instance_of?(superclass)
+
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/interfaces/error_interface.rb

@@ -10,9 +10,18 @@ module LowType
       @output_size = LowType.config.output_size
     end
 
+    def error_type
+      raise NotImplementedError
+    end
+
+    def error_message(value:)
+      raise NotImplementedError
+    end
+
     def output(value:)
       case @output_mode
       when :type
+        # TODO: Show full type structure in error output instead of just the type of the supertype.
         value.class
       when :value
         value.inspect[0...@output_size]
@@ -21,12 +30,16 @@ module LowType
       end
     end
 
-    def error_type
-      raise NotImplementedError
-    end
+    def backtrace(backtrace:, hidden_paths:)
+      # Remove LowType defined method file paths from the backtrace.
+      filtered_backtrace = backtrace.reject { |line| hidden_paths.find { |file_path| line.include?(file_path) } }
 
-    def error_message(value:)
-      raise NotImplementedError
+      # Add the proxied file to the backtrace.
+      proxy_file_backtrace = "#{file.path}:#{file.line}:in '#{file.scope}'"
+      from_prefix = filtered_backtrace.first.match(/\s+from /)
+      proxy_file_backtrace = "#{from_prefix}#{proxy_file_backtrace}" if from_prefix
+
+      [proxy_file_backtrace, *filtered_backtrace]
     end
   end
 end

data/lib/queries/type_query.rb

@@ -1,27 +1,35 @@
 # frozen_string_literal: true
 
+require_relative '../type_expression'
+
 module LowType
   # TODO: Unit test.
   class TypeQuery
     class << self
-      def type?(type)
-        basic_type?(type:) || complex_type?(type:)
+      def type?(expression)
+        basic_type?(expression:) || complex_type?(expression:)
+      end
+
+      def typed_array?(expression:)
+        expression.is_a?(Array) && (basic_type?(expression: expression.first) || expression.first.is_a?(TypeExpression))
       end
 
-      def basic_type?(type:)
-        type.instance_of?(Class)
+      def value?(value)
+        !basic_type?(expression: value) && !complex_type?(expression: value)
       end
 
-      def complex_type?(type:)
-        !basic_type?(type:) && typed_hash?(type:)
+      def complex_type?(expression:)
+        LowType::COMPLEX_TYPES.include?(expression) || typed_array?(expression:) || typed_hash?(expression:)
       end
 
-      def typed_hash?(type:)
-        type.is_a?(::Hash) && basic_type?(type: type.keys.first) && basic_type?(type: type.values.first)
+      private
+
+      def basic_type?(expression:)
+        expression.instance_of?(Class)
       end
 
-      def value?(expression)
-        !expression.respond_to?(:new) && expression != Integer
+      def typed_hash?(expression:)
+        expression.is_a?(Hash) && basic_type?(expression: expression.keys.first) && basic_type?(expression: expression.values.first)
       end
     end
   end

data/lib/redefiner.rb

@@ -106,7 +106,7 @@ module LowType
           }
         RUBY
 
-        # Called with only required args (as nil) and optional args omitted, to evaluate type expressions (stored as default values).
+        # Called with only required args (as nil) and optional args omitted, to evaluate type expressions (from default values).
         eval(typed_method, binding, __FILE__, __LINE__).call(*required_args, **required_kwargs) # rubocop:disable Security/Eval
 
       # TODO: Write spec for this.

data/lib/syntax/syntax.rb

@@ -5,8 +5,8 @@ require_relative '../queries/type_query'
 module LowType
   module Syntax
     refine Array.singleton_class do
-      def [](*types)
-        return TypeExpression.new(type: [*types]) if types.all? { |type| TypeQuery.type?(type) }
+      def [](*expression)
+        return TypeExpression.new(type: [*expression]) if TypeQuery.type?(expression.first) || TypeQuery.typed_array?(expression:)
 
         super
       end

data/lib/type_expression.rb

@@ -5,10 +5,10 @@ require_relative 'queries/type_query'
 
 module LowType
   root_path = File.expand_path(__dir__)
-  file_path = File.expand_path(__FILE__)
   adapter_paths = Dir.chdir(root_path) { Dir.glob('adapters/*') }.map { |path| File.join(root_path, path) }
+  module_paths = %w[instance_types local_types redefiner].map { |path| File.join(root_path, "#{path}.rb") }
 
-  HIDDEN_PATHS = [file_path, *adapter_paths, File.join(root_path, 'redefiner.rb')].freeze
+  HIDDEN_PATHS = [File.expand_path(__FILE__), *adapter_paths, *module_paths].freeze
 
   # Represent types and default values as a series of chainable expressions.
   class TypeExpression
@@ -19,6 +19,8 @@ module LowType
       @types = []
       @types << type unless type.nil?
       @default_value = default_value
+      # TODO: Override per type expression with a config expression.
+      @deep_type_check = LowType.config.deep_type_check
     end
 
     def |(expression)
@@ -45,64 +47,94 @@ module LowType
       end
 
       @types.each do |type|
-        # Example: HTML is a subclass of String and should pass as a String.
-        return true if LowType::TypeQuery.basic_type?(type:) && type <= value.class
-        return true if type.is_a?(::Array) && value.is_a?(::Array) && array_types_match_values?(types: type, values: value)
-        return true if type.is_a?(::Hash) && value.is_a?(::Hash) && hash_types_match_values?(type:, value:)
+        return true if type_matches_value?(type:, value:, proxy:)
+        return true if type.is_a?(Array) && value.is_a?(Array) && array_types_match_values?(types: type, values: value, proxy:)
+        return true if type.is_a?(Hash) && value.is_a?(Hash) && hash_types_match_values?(types: type, values: value)
       end
 
       raise proxy.error_type, proxy.error_message(value:)
     rescue proxy.error_type => e
-      raise proxy.error_type, e.message, backtrace_with_proxy(backtrace: e.backtrace, proxy:)
+      raise proxy.error_type, e.message, proxy.backtrace(backtrace: e.backtrace, hidden_paths: HIDDEN_PATHS)
     end
 
     def valid_types
       types = @types.map do |type|
-        # Remove 'LowType::' namespace in subtypes.
-        if type.is_a?(::Array)
-          "[#{type.map { |subtype| subtype.to_s.delete_prefix('LowType::') }.join(', ')}]"
+        if type.is_a?(Array)
+          "[#{type.map { |subtype| valid_subtype(subtype:) }.join(', ')}]"
         else
           type.inspect.to_s.delete_prefix('LowType::')
         end
       end
 
-      types += ['nil'] if @default_value.nil?
+      types << 'nil' if @default_value.nil?
       types.join(' | ')
     end
 
     private
 
-    def array_types_match_values?(types:, values:)
-      # [T, T, T]
+    def valid_subtype(subtype:)
+      if subtype.is_a?(TypeExpression)
+        types = subtype.types
+        types << 'nil' if subtype.default_value.nil?
+        types.join(' | ')
+      else
+        subtype.to_s.delete_prefix('LowType::')
+      end
+    end
+
+    def array_types_match_values?(types:, values:, proxy:)
+      # [X, Y, Z] An arbitrary amount of elements are arbitrary types in an arbitrary order.
       if types.length > 1
-        types.each_with_index do |type, index|
-          # Example: HTML is a subclass of String and should pass as a String.
-          return false unless type <= values[index].class
-        end
-      # [T]
+        return multiple_types_match_values?(types:, values:, proxy:)
+      # [T] All elements are the same type.
       elsif types.length == 1
-        return false unless types.first == values.first.class
+        return single_type_matches_values?(type: types.first, values:, proxy:)
+      end
+
+      # [] Misconfigured empty Array[] type.
+      true
+    end
+
+    def multiple_types_match_values?(types:, values:, proxy:)
+      types.each_with_index do |type, index|
+        return false unless type_matches_value?(type:, value: values[index], proxy:)
       end
-      # TODO: Deep type check (all elements for [T]).
 
       true
     end
 
-    def hash_types_match_values?(type:, value:)
+    def single_type_matches_values?(type:, values:, proxy:)
+      # [V, ...] Type check all elements.
+      if deep_type_check?
+        return false if values.any? { |value| !type_matches_value?(type:, value:, proxy:) }
+      # [V] Type check the first element.
+      else
+        return false unless type_matches_value?(type:, value: values.first, proxy:)
+      end
+
+      true
+    end
+
+    def hash_types_match_values?(types:, values:)
       # TODO: Shallow validation of hash could be made deeper with user config.
-      type.keys[0] == value.keys[0].class && type.values[0] == value.values[0].class
+      types.keys[0] == values.keys[0].class && types.values[0] == values.values[0].class
     end
 
-    def backtrace_with_proxy(proxy:, backtrace:)
-      # Remove LowType defined method file paths from the backtrace.
-      filtered_backtrace = backtrace.reject { |line| HIDDEN_PATHS.find { |file_path| line.include?(file_path) } }
+    def type_matches_value?(type:, value:, proxy:)
+      if type.instance_of?(Class)
+        return type.match?(value:) if LowType::TypeQuery.complex_type?(expression: type)
+
+        return type == value.class
+      elsif type.instance_of?(::LowType::TypeExpression)
+        type.validate!(value:, proxy:)
+        return true
+      end
 
-      # Add the proxied file to the backtrace.
-      proxy_file_backtrace = "#{proxy.file.path}:#{proxy.file.line}:in '#{proxy.file.scope}'"
-      from_prefix = filtered_backtrace.first.match(/\s+from /)
-      proxy_file_backtrace = "#{from_prefix}#{proxy_file_backtrace}" if from_prefix
+      false
+    end
 
-      [proxy_file_backtrace, *filtered_backtrace]
+    def deep_type_check?
+      @deep_type_check || LowType.config.deep_type_check || false
     end
   end
 end

data/lib/types/complex_types.rb

@@ -1,12 +1,15 @@
 # frozen_string_literal: true
 
+require_relative '../factories/type_factory'
+
 module LowType
-  # TrueClass or FalseClass
-  class Boolean; end
-  class Tuple < Array; end
-  class Status < Integer; end
-  class Headers < Hash; end
-  class HTML < String; end
-  class JSON < String; end
-  class XML < String; end
+  COMPLEX_TYPES = [
+    Boolean = TypeFactory.complex_type(Object),
+    Headers = TypeFactory.complex_type(Hash),
+    HTML = TypeFactory.complex_type(String),
+    JSON = TypeFactory.complex_type(String),
+    Status = TypeFactory.complex_type(Integer),
+    Tuple = TypeFactory.complex_type(Array),
+    XML = TypeFactory.complex_type(String)
+  ].freeze
 end

data/lib/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: low_type
 version: !ruby/object:Gem::Version
-  version: 1.0.8
+  version: 1.1.1
 platform: ruby
 authors:
 - maedi
@@ -21,6 +21,7 @@ files:
 - lib/adapters/sinatra_adapter.rb
 - lib/factories/expression_factory.rb
 - lib/factories/proxy_factory.rb
+- lib/factories/type_factory.rb
 - lib/instance_types.rb
 - lib/interfaces/adapter_interface.rb
 - lib/interfaces/error_interface.rb