typelizer 0.9.1 → 0.9.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 82ca16632db02541212afb1fa0cd9b47bbaa10a375b68c4d830e4264eeec5fd8
-  data.tar.gz: c12d5e0a2aea772483d92b8290dcfa9c6a5e5e38febebf3d986db126f00e4d87
+  metadata.gz: 9e0f1018fd5d37ab4171501db8961c7895e796f1f41bf292c773f6d39fa08832
+  data.tar.gz: 3ab825f73e774cb8d13bb61772c878501e25b42f7e1b3ad35ae2a7a6a31e2d32
 SHA512:
-  metadata.gz: 5e04629e8669b5ed6c610c85246ea06d3bda46100d2d9d876ad2d0ae6904669aeb569b689b4634df39217a392028bb968060f30a7b4f1f6a47c6374c0604d84d
-  data.tar.gz: ba808f9f614f856fcd6f3c496b990bbb1ead4530e0214d3d55cbadd62a63e5a9846623ff446d006570d5b4c2b499bfe7bb46c9049c95dc74caf9df81e7a80187
+  metadata.gz: 31b6a138ee7ae3c95f173f2df1f2168469b285aeff266c350c27a95b51021fa2deeb43bea1f9b28a0f9a4114a6ff4af9f82e47e64f04dcf314c88dfa9d042936
+  data.tar.gz: ccd0cb33a718fedae63e46e83bc7495d6b3520d7bfe6b190e2021e98f0f986ed36ca970dd25a71acbcc9017fd1b4b7579fb2399cf6727c92c2a13a1f38d84d80

data/CHANGELOG.md

@@ -7,6 +7,19 @@ and this project adheres to [Semantic Versioning].
 
 ## [Unreleased]
 
+## [0.9.3] - 2026-02-27
+
+### Fixed
+
+- Fix keyless `typelize` DSL without name. ([@skryukov])
+- Support arrays for keyless `typelize` calls. ([@skryukov])
+
+## [0.9.2] - 2026-02-26
+
+### Fixed
+
+- Fix string literal unions in OpenAPI and bracket-aware union type splitting. ([@skryukov])
+
 ## [0.9.1] - 2026-02-26
 
 ### Fixed
@@ -420,7 +433,9 @@ and this project adheres to [Semantic Versioning].
 [@skryukov]: https://github.com/skryukov
 [@ventsislaf]: https://github.com/ventsislaf
 
-[Unreleased]: https://github.com/skryukov/typelizer/compare/v0.9.1...HEAD
+[Unreleased]: https://github.com/skryukov/typelizer/compare/v0.9.3...HEAD
+[0.9.3]: https://github.com/skryukov/typelizer/compare/v0.9.2...v0.9.3
+[0.9.2]: https://github.com/skryukov/typelizer/compare/v0.9.1...v0.9.2
 [0.9.1]: https://github.com/skryukov/typelizer/compare/v0.9.0...v0.9.1
 [0.9.0]: https://github.com/skryukov/typelizer/compare/v0.8.0...v0.9.0
 [0.8.0]: https://github.com/skryukov/typelizer/compare/v0.7.0...v0.8.0

data/lib/typelizer/dsl/hooks.rb

@@ -29,7 +29,7 @@ module Typelizer
           return unless keyless_type
 
           type, attrs = keyless_type
-          typelize(name => [type, attrs])
+          store_type(:_typelizer_attributes, name, attrs.merge(type: type))
           self.keyless_type = nil
         end
 

data/lib/typelizer/dsl.rb

@@ -73,11 +73,26 @@ module Typelizer
         assign_type_information(:_typelizer_meta_attributes, attributes)
       end
 
+      def store_type(attribute_name, name, options)
+        ensure_type_store(attribute_name)
+        instance_variable_get("@#{attribute_name}")[name.to_sym] ||= {}
+        instance_variable_get("@#{attribute_name}")[name.to_sym].merge!(options)
+      end
+
       private
 
       def assign_type_information(attribute_name, attributes)
         return unless Typelizer.enabled?
 
+        attributes.each do |name, attrs|
+          next unless name
+
+          options = parse_type_declaration(attrs)
+          store_type(attribute_name, name, options)
+        end
+      end
+
+      def ensure_type_store(attribute_name)
         instance_variable = "@#{attribute_name}"
 
         unless instance_variable_get(instance_variable)
@@ -96,29 +111,26 @@ module Typelizer
             end
           end
         end
+      end
 
-        attributes.each do |name, attrs|
-          next unless name
-
-          attrs = [attrs] if attrs && !attrs.is_a?(Array)
-          options = attrs.last.is_a?(Hash) ? attrs.pop : {}
-
-          if attrs.any?
-            parsed_types = attrs.map { |t| TypeParser.parse(t) }
-            all_types = parsed_types.flat_map { |p| Array(p[:type]) }
-            parsed_types.each do |parsed|
-              options[:optional] = true if parsed[:optional]
-              options[:multi] = true if parsed[:multi]
-              options[:nullable] = true if parsed[:nullable]
-            end
-            options[:nullable] = true if all_types.delete(:null)
-            # Unwrap single-element arrays: typelize field: ["string"] behaves like typelize field: "string"
-            options[:type] = (all_types.size == 1) ? all_types.first : all_types
+      def parse_type_declaration(attrs)
+        attrs = [attrs] if attrs && !attrs.is_a?(Array)
+        options = attrs.last.is_a?(Hash) ? attrs.pop : {}
+
+        if attrs.any?
+          parsed_types = attrs.map { |t| TypeParser.parse(t) }
+          all_types = parsed_types.flat_map { |p| Array(p[:type]) }
+          parsed_types.each do |parsed|
+            options[:optional] = true if parsed[:optional]
+            options[:multi] = true if parsed[:multi]
+            options[:nullable] = true if parsed[:nullable]
           end
-
-          instance_variable_get(instance_variable)[name.to_sym] ||= {}
-          instance_variable_get(instance_variable)[name.to_sym].merge!(options)
+          options[:nullable] = true if all_types.delete(:null)
+          # Unwrap single-element arrays: typelize field: ["string"] behaves like typelize field: "string"
+          options[:type] = (all_types.size == 1) ? all_types.first : all_types
         end
+
+        options
       end
     end
   end

data/lib/typelizer/openapi.rb

@@ -89,9 +89,11 @@ module Typelizer
       end
 
       def union_schema(property, openapi_version:)
-        schemas = property.type.map { |part| union_member_schema(part) }
-
-        definition = {anyOf: schemas}
+        definition = if property.type.all? { |part| string_literal?(part) }
+          {type: :string, enum: property.type.map { |part| unquote_string_literal(part) }}
+        else
+          {anyOf: property.type.map { |part| union_member_schema(part) }}
+        end
 
         unless property.multi
           apply_nullable(definition, property, openapi_version: openapi_version)
@@ -154,6 +156,8 @@ module Typelizer
         elsif definition[:type]
           v31?(openapi_version) ? definition[:type] = [definition[:type], :null] : definition[:nullable] = true
         end
+
+        definition[:enum] << nil if definition[:enum].is_a?(Array) && !definition[:enum].include?(nil)
       end
 
       def wrap_multi(definition, property, openapi_version:)
@@ -180,6 +184,8 @@ module Typelizer
           result = COLUMN_TYPE_MAP[property.column_type].dup
           result[:type] = :string if property.enum
           result
+        elsif string_literal?(property.type)
+          {type: :string, enum: [unquote_string_literal(property.type)]}
         elsif (property.type.is_a?(String) || property.type.is_a?(Symbol)) && !OPENAPI_TYPES.include?(property.type.to_sym) && !ts_only_type?(property.type.to_s)
           {"$ref" => "#/components/schemas/#{property.type}"}
         else
@@ -206,6 +212,16 @@ module Typelizer
         type_str.start_with?("{", "[") || type_str.include?("<") || TS_OBJECT_TYPES.include?(type_str)
       end
 
+      def string_literal?(type)
+        str = type.to_s
+        str.length > 2 &&
+          ((str.start_with?("'") && str.end_with?("'")) || (str.start_with?('"') && str.end_with?('"')))
+      end
+
+      def unquote_string_literal(type)
+        type.to_s[1..-2]
+      end
+
       def validate_version!(openapi_version)
         raise ArgumentError, "Unsupported openapi_version: #{openapi_version}. Must be one of: #{SUPPORTED_VERSIONS.join(", ")}" unless SUPPORTED_VERSIONS.include?(openapi_version.to_s)
       end

data/lib/typelizer/type_parser.rb

@@ -12,6 +12,7 @@ module Typelizer
     class << self
       def parse(type_def, **options)
         return options if type_def.nil?
+        return parse_array(type_def, **options) if type_def.is_a?(Array)
 
         type_str = type_def.to_s
         return parse_union(type_str, **options) if type_str.include?("|")
@@ -39,8 +40,31 @@ module Typelizer
 
       private
 
+      def parse_array(type_defs, **options)
+        parsed = type_defs.map { |t| parse(t) }
+        types = parsed.flat_map { |p| Array(p[:type]) }
+
+        parsed.each do |p|
+          options[:optional] = true if p[:optional]
+          options[:multi] = true if p[:multi]
+          options[:nullable] = true if p[:nullable]
+        end
+
+        options[:nullable] = true if types.delete(:null)
+
+        if types.size == 1
+          {type: types.first}.merge(options)
+        else
+          {type: types}.merge(options)
+        end
+      end
+
       def parse_union(type_str, **options)
-        parts = type_str.split(/\s*\|\s*/)
+        parts = UnionTypeSorter.split_union_members(type_str)
+
+        # No top-level | found — the | is nested inside brackets
+        return {type: type_str.to_sym}.merge(options) if parts.size <= 1
+
         options[:nullable] = true if parts.delete("null")
         if parts.size == 1
           parse(parts.first, **options)

data/lib/typelizer/union_type_sorter.rb

@@ -98,10 +98,10 @@ module Typelizer
 
       str.each_char do |char|
         case char
-        when "<", "("
+        when "<", "(", "{", "["
           depth += 1
           current << char
-        when ">", ")"
+        when ">", ")", "}", "]"
           depth -= 1
           current << char
         when "|"
@@ -126,6 +126,8 @@ module Typelizer
     def self.balanced_brackets?(str)
       angle_depth = 0
       paren_depth = 0
+      brace_depth = 0
+      bracket_depth = 0
 
       str.each_char do |char|
         case char
@@ -139,10 +141,20 @@ module Typelizer
         when ")"
           paren_depth -= 1
           return false if paren_depth < 0
+        when "{"
+          brace_depth += 1
+        when "}"
+          brace_depth -= 1
+          return false if brace_depth < 0
+        when "["
+          bracket_depth += 1
+        when "]"
+          bracket_depth -= 1
+          return false if bracket_depth < 0
         end
       end
 
-      angle_depth == 0 && paren_depth == 0
+      angle_depth == 0 && paren_depth == 0 && brace_depth == 0 && bracket_depth == 0
     end
   end
 end

data/lib/typelizer/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Typelizer
-  VERSION = "0.9.1"
+  VERSION = "0.9.3"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: typelizer
 version: !ruby/object:Gem::Version
-  version: 0.9.1
+  version: 0.9.3
 platform: ruby
 authors:
 - Svyatoslav Kryukov