structure 3.4.0 → 3.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2a7bd562939e000315d1904c5f766c0293c570413aa69930e522a01e70849715
-  data.tar.gz: '0649cee7d47286ad9ba6e36721cc350f20a9ba40c971214e0edb91bde8bec7d9'
+  metadata.gz: 5f6aed363a91e514906a1c005fe2af6ec3583fa8742f997055def47e1f085c0c
+  data.tar.gz: 574b02c68a6a84f98384d9ba60c8b2d88b95c2cb3db49aa2eccb61e3e1dfc9ab
 SHA512:
-  metadata.gz: 3d09a3983e553ccbf3f031c2bb2f920b430032ee5d778b1572f9423e2593808e458662f77615fc84a002136b0896a7bfb5ceff0119d880df1fc833f4123dd493
-  data.tar.gz: ec6da8a717b8ccab314c808bb9ab3218d733790378f3b61dbdf52dffbf4b28fd7fd7d6ae7b484d390809a8396fccd894b0d087a3d1a90926149bc55db5a98848
+  metadata.gz: 0a73835caa30f00145df491efd1bbcedbb2a7ada0cd0b2328cc8c0d9004bd51607328883630529165e9863a9852df40e17414854133a1d1d0144f690e49a50ef
+  data.tar.gz: ecb9bc59302300646d8dad3ea1345aecf236aec833e35cf1c83cedbfe5de5369c87965f3877d93e952cbf3536ff603fea2564032a07dba3db77c9872a4d46318

data/lib/structure/builder.rb

@@ -33,16 +33,13 @@ module Structure
     #     Money.new(value["amount"], value["currency"])
     #   end
     def attribute(name, type = nil, from: nil, default: nil, &block)
-      # Always store in mappings - use attribute name as default source
-      @mappings[name] = from || name.to_s
-      @defaults[name] = default unless default.nil?
+      mappings[name] = from || name.to_s
+      defaults[name] = default unless default.nil?
 
       if type && block
         raise ArgumentError, "Cannot specify both type and block for :#{name}"
-      elsif block
-        @types[name] = block
-      elsif type
-        @types[name] = type
+      else
+        types[name] = type || block
       end
     end
 
@@ -63,8 +60,8 @@ module Structure
       @mappings.keys
     end
 
-    def coercions
-      @types.transform_values { |type| Types.coerce(type) }
+    def coercions(context_class = nil)
+      @types.transform_values { |type| Types.coerce(type, context_class) }
     end
 
     def predicate_methods

data/lib/structure/rbs.rb

@@ -12,12 +12,13 @@ module Structure
         class_name = klass.name
         return unless class_name
 
+        # @type var meta: Hash[Symbol, untyped]
         meta = klass.respond_to?(:__structure_meta__) ? klass.__structure_meta__ : {}
 
         emit_rbs_content(
           class_name: class_name,
           attributes: meta.fetch(:attributes, klass.members),
-          types: meta.fetch(:types, {}),
+          types: meta.fetch(:types, {}), # steep:ignore
           has_structure_modules: meta.any?,
         )
       end
@@ -35,20 +36,18 @@ module Structure
         dir_path = dir_path.join(*path_segments) unless path_segments.empty?
         FileUtils.mkdir_p(dir_path)
 
-        file_path = dir_path.join(filename)
+        file_path = dir_path.join(filename).to_s
         File.write(file_path, rbs_content)
 
-        file_path.to_s
+        file_path
       end
 
       private
 
       def emit_rbs_content(class_name:, attributes:, types:, has_structure_modules:)
+        # @type var lines: Array[String]
         lines = []
         lines << "class #{class_name} < Data"
-        lines << "  extend Structure::ClassMethods" if has_structure_modules
-        lines << "  include Structure::InstanceMethods"
-        lines << ""
 
         unless attributes.empty?
           # map types to rbs
@@ -66,6 +65,28 @@ module Structure
           lines << "              | (#{positional_params}) -> instance"
           lines << ""
 
+          needs_parse_data = types.any? do |_attr, type|
+            type == :self || type == [:self] || (type.is_a?(Array) && type.first == :array)
+          end
+
+          if needs_parse_data
+            lines << "  type parse_data = {"
+            attributes.each do |attr|
+              type = types.fetch(attr, nil)
+              parse_type = parse_data_type(type, class_name)
+              lines << "    ?#{attr}: #{parse_type},"
+            end
+            lines[-1] = lines[-1].chomp(",")
+            lines << "  }"
+            lines << ""
+            lines << "  def self.parse: (?parse_data data) -> instance"
+            lines << "                | (?Hash[String, untyped] data) -> instance"
+          else
+            # For structures without special types, just use Hash
+            lines << "  def self.parse: (?(Hash[String | Symbol, untyped]), **untyped) -> instance"
+          end
+          lines << ""
+
           attributes.each do |attr|
             lines << "  attr_reader #{attr}: #{rbs_types[attr]}"
           end
@@ -85,6 +106,33 @@ module Structure
         lines.join("\n")
       end
 
+      def parse_data_type(type, class_name)
+        case type
+        when [:self]
+          "Array[#{class_name} | parse_data]"
+        when Array
+          if type.first == :array && type.last == :self
+            "Array[#{class_name} | parse_data]"
+          elsif type.first == :array
+            # For [:array, SomeType] format, use Array[untyped] since we coerce
+            "Array[untyped]"
+          elsif type.size == 1 && type.first == :self
+            # [:self] is handled above, this shouldn't happen
+            "Array[#{class_name} | parse_data]"
+          elsif type.size == 1
+            # Regular array type like [String], [Integer], etc.
+            # Use Array[untyped] since we coerce values
+            "Array[untyped]"
+          else
+            "untyped"
+          end
+        when :self
+          "#{class_name} | parse_data"
+        else
+          "untyped"
+        end
+      end
+
       def map_type_to_rbs(type, class_name)
         case type
         when Class
@@ -97,8 +145,10 @@ module Structure
           if type.size == 2 && type.first == :array
             element_type = map_type_to_rbs(type.last, class_name)
             "Array[#{element_type}]"
-          elsif type == [:self]
-            "Array[#{class_name || "untyped"}]"
+          elsif type.size == 1
+            # Single element array means array of that type
+            element_type = map_type_to_rbs(type.first, class_name)
+            "Array[#{element_type}]"
           else
             "untyped"
           end

data/lib/structure/types.rb

@@ -3,77 +3,139 @@
 module Structure
   # Type coercion methods for converting values to specific types
   module Types
-    extend self
+    class << self
+      # Rails-style boolean truthy values
+      # Reference: https://api.rubyonrails.org/classes/ActiveModel/Type/Boolean.html
+      BOOLEAN_TRUTHY = [true, 1, "1", "t", "T", "true", "TRUE", "on", "ON"].freeze
+      private_constant :BOOLEAN_TRUTHY
 
-    # Rails-style boolean truthy values
-    # Reference: https://api.rubyonrails.org/classes/ActiveModel/Type/Boolean.html
-    BOOLEAN_TRUTHY = [true, 1, "1", "t", "T", "true", "TRUE", "on", "ON"].freeze
-    private_constant :BOOLEAN_TRUTHY
-
-    # Main factory method for creating type coercers
-    #
-    # @param type [Class, Symbol, Array] Type specification
-    # @return [Proc, Object] Coercion proc or the type itself if no coercion available
-    #
-    # @example Boolean type
-    #   coerce(:boolean) # => boolean proc
-    #
-    # @example Kernel types
-    #   coerce(Integer) # => proc that calls Kernel.Integer
-    #
-    # @example Parseable types
-    #   coerce(Date) # => proc that calls Date.parse
-    #
-    # @example Array types
-    #   coerce([String]) # => proc that coerces array elements to String
-    def coerce(type)
-      case type
-      when :boolean
-        boolean
-      when :self
-        self_referential
-      when Array
-        if type.length == 1
-          array(type.first)
+      # Main factory method for creating type coercers
+      #
+      # @param type [Class, Symbol, Array, String] Type specification
+      # @return [Proc, Object] Coercion proc or the type itself if no coercion available
+      #
+      # @example Boolean type
+      #   coerce(:boolean) # => boolean proc
+      #
+      # @example Kernel types
+      #   coerce(Integer) # => proc that calls Kernel.Integer
+      #
+      # @example Parseable types
+      #   coerce(Date) # => proc that calls Date.parse
+      #
+      # @example Array types
+      #   coerce([String]) # => proc that coerces array elements to String
+      #
+      # @example String class name (lazy resolved)
+      #   coerce("MyClass") # => proc that resolves and coerces to MyClass
+      def coerce(type, context_class = nil)
+        case type
+        when :boolean
+          boolean
+        when :self
+          self_referential
+        when String
+          string_class(type, context_class)
+        when Array
+          if type.length == 1
+            array(type.first, context_class)
+          else
+            type
+          end
         else
-          type
+          if type.respond_to?(:parse)
+            parseable(type)
+          elsif type.respond_to?(:name) && type.name && Kernel.respond_to?(type.name)
+            kernel(type)
+          else
+            type
+          end
         end
-      else
-        # Handle Class, Module, and any other types
-        if type.respond_to?(:parse)
-          parseable(type)
-        elsif type.respond_to?(:name) && type.name && Kernel.respond_to?(type.name)
-          kernel(type)
+      end
+
+      def resolve_class(class_name, context_class)
+        if context_class && defined?(context_class.name)
+          namespace = context_class.name.to_s.split("::")[0...-1]
+          if namespace.any?
+            begin
+              namespace.reduce(Object) { |mod, name| mod.const_get(name) }.const_get(class_name)
+            rescue NameError
+              Object.const_get(class_name)
+            end
+          else
+            Object.const_get(class_name)
+          end
         else
-          type
+          Object.const_get(class_name)
         end
+      rescue NameError => e
+        raise NameError, "Unable to resolve class '#{class_name}': #{e.message}"
       end
-    end
 
-    private
+      private
 
-    def boolean
-      @boolean ||= ->(val) { BOOLEAN_TRUTHY.include?(val) }
-    end
+      def boolean
+        @boolean ||= ->(val) { BOOLEAN_TRUTHY.include?(val) }
+      end
 
-    def self_referential
-      proc { |val| parse(val) }
-    end
+      def self_referential
+        proc { |val| parse(val) }
+      end
 
-    def kernel(type)
-      ->(val) { Kernel.send(type.name, val) }
-    end
+      def kernel(type)
+        ->(val) { Kernel.send(type.name, val) }
+      end
 
-    def parseable(type)
-      ->(val) { type.parse(val) }
-    end
+      def parseable(type)
+        ->(val) { type.parse(val) }
+      end
+
+      def string_class(class_name, context_class)
+        resolved_class = nil
+        proc do |value|
+          resolved_class ||= Structure::Types.resolve_class(class_name, context_class)
+          if resolved_class.respond_to?(:parse)
+            resolved_class.parse(value) # steep:ignore
+          else
+            value
+          end
+        end
+      end
 
-    def array(element_type)
-      if element_type == :self
-        proc { |array| array.map { |element| parse(element) } }
-      else
-        element_coercer = coerce(element_type)
-        ->(array) { array.map { |element| element_coercer.call(element) } }
+      def array(element_type, context_class = nil)
+        if element_type == :self
+          proc do |value|
+            unless value.respond_to?(:map)
+              raise TypeError, "can't convert #{value.class} into Array"
+            end
+
+            value.map { |element| parse(element) }
+          end
+        elsif element_type.is_a?(String)
+          proc do |value|
+            unless value.respond_to?(:map)
+              raise TypeError, "can't convert #{value.class} into Array"
+            end
+
+            resolved_class = Structure::Types.resolve_class(element_type, context_class)
+            value.map do |element|
+              if resolved_class.respond_to?(:parse)
+                resolved_class.parse(element)
+              else
+                element
+              end
+            end
+          end
+        else
+          element_coercer = coerce(element_type, context_class)
+          lambda do |value|
+            unless value.respond_to?(:map)
+              raise TypeError, "can't convert #{value.class} into Array"
+            end
+
+            value.map { |element| element_coercer.call(element) }
+          end
+        end
       end
     end
   end

data/lib/structure/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Structure
-  VERSION = "3.4.0"
+  VERSION = "3.6.0"
 end

data/lib/structure.rb

@@ -23,6 +23,7 @@ module Structure
       builder = Builder.new
       builder.instance_eval(&block) if block
 
+      # @type var klass: untyped
       klass = Data.define(*builder.attributes)
 
       # capture metadata and attach to class
@@ -36,19 +37,20 @@ module Structure
 
       # capture locals for method generation
       mappings = builder.mappings
-      coercions = builder.coercions
+      coercions = builder.coercions(klass)
       predicates = builder.predicate_methods
       after = builder.after_parse_callback
 
       # Define predicate methods
       predicates.each do |pred, attr|
-        klass.define_method(pred) { public_send(attr) }
+        klass.define_method(pred) { !!public_send(attr) }
       end
 
       # recursive to_h
       klass.define_method(:to_h) do
-        #: Hash[Symbol, untyped]
-        self.class.members.each_with_object({}) do |m, h|
+        # @type var h: Hash[Symbol, untyped]
+        h = {}
+        klass.members.each do |m|
           v = public_send(m)
           h[m] =
             case v
@@ -57,23 +59,38 @@ module Structure
             else v
             end
         end
+        h
       end
 
       # parse accepts JSON-ish hashes + kwargs override
       klass.define_singleton_method(:parse) do |data = {}, **kwargs|
-        string_kwargs = kwargs.transform_keys(&:to_s)
-        data = data.merge(string_kwargs)
+        return data if data.is_a?(self)
+
+        unless data.respond_to?(:merge!)
+          raise TypeError, "can't convert #{data.class} into #{self}"
+        end
 
-        #: Hash[Symbol, untyped]
+        # @type var kwargs: Hash[Symbol, untyped]
+        string_kwargs = kwargs.transform_keys(&:to_s)
+        data.merge!(string_kwargs)
+        # @type self: singleton(Data) & _StructuredDataClass
+        # @type var final: Hash[Symbol, untyped]
         final = {}
+
+        # TODO: `__structure_meta__` exists but seems not to return the types it defines, so going untyped for now
+        #
+        # @type var meta: untyped
         meta = __structure_meta__
 
-        meta[:attributes].each do |attr|
+        attributes = meta.fetch(:attributes)
+        defaults = meta.fetch(:defaults)
+
+        attributes.each do |attr|
           source = mappings[attr] || attr.to_s
           value =
             if data.key?(source)            then data[source]
             elsif data.key?(source.to_sym)  then data[source.to_sym]
-            elsif meta[:defaults].key?(attr) then meta[:defaults][attr]
+            elsif defaults.key?(attr) then defaults[attr]
             end
 
           coercion = coercions[attr]
@@ -81,7 +98,7 @@ module Structure
             # self-referential types need class context to call parse
             value =
               if coercion.is_a?(Proc) && !coercion.lambda?
-                instance_exec(value, &coercion)
+                instance_exec(value, &coercion) # steep:ignore
               else
                 coercion.call(value)
               end
@@ -90,7 +107,6 @@ module Structure
           final[attr] = value
         end
 
-        #: untyped
         obj = new(**final)
         after&.call(obj)
         obj

data/sig/structure/builder.rbs

@@ -1,16 +1,20 @@
 module Structure
   class Builder
-    def attribute: (Symbol name, untyped type, ?from: String, ?default: untyped) ?{ (untyped) -> untyped } -> void
+    @mappings: Hash[Symbol, String]
+    @types: Hash[Symbol, untyped]
+    @defaults: Hash[Symbol, untyped]
+    @after_parse_callback: Proc?
+
+    def attribute: (Symbol name, untyped type, ?from: String?, ?default: untyped) ?{ (untyped) -> untyped } -> void
                  | (Symbol name, ?from: String, ?default: untyped) ?{ (untyped) -> untyped } -> void
 
     def after_parse: () { (Data) -> void } -> void
 
-    # Methods used by the factory after the block
     def attributes: () -> Array[Symbol]
     def mappings: () -> Hash[Symbol, String]
     def types: () -> Hash[Symbol, untyped]
     def defaults: () -> Hash[Symbol, untyped]
-    def coercions: () -> Hash[Symbol, Proc]
+    def coercions: (?untyped? context_class) -> Hash[Symbol, Proc]
     def predicate_methods: () -> Hash[Symbol, Symbol]
     def after_parse_callback: () -> (Proc | nil)
   end

data/sig/structure/rbs.rbs

@@ -1,11 +1,10 @@
 module Structure
   module RBS
-    def self.emit: (Class klass) -> String?
-    def self.write: (Class klass, ?dir: String) -> String?
+    def self.emit: (untyped klass) -> String?
+    def self.write: (untyped klass, ?dir: String) -> String?
 
-    private
-
-    def self.emit_rbs_content: (class_name: String, attributes: Array[Symbol], types: Hash[Symbol, untyped], has_structure_modules: bool) -> String
-    def self.map_type_to_rbs: (untyped type, String class_name) -> String
+    private def self.emit_rbs_content: (class_name: String, attributes: Array[Symbol], types: Hash[Symbol, untyped], has_structure_modules: bool) -> String
+    private def self.parse_data_type: (untyped type, String class_name) -> String
+    private def self.map_type_to_rbs: (untyped type, String class_name) -> String
   end
 end

data/sig/structure/types.rbs

@@ -2,15 +2,17 @@ module Structure
   module Types
     BOOLEAN_TRUTHY: Array[untyped]
 
-    def self.coerce: (untyped type) -> Proc
+    self.@boolean: Proc
 
-    private
+    def self.coerce: (untyped type, ?untyped? context_class) -> untyped
+    def self.resolve_class: (String class_name, untyped? context_class) -> untyped
 
-    def self.boolean: () -> Proc
-    def self.self_referential: () -> Proc
-    def self.array: (untyped element_type) -> Proc
-    def self.parseable: (Class type) -> Proc
-    def self.kernel: (Class type) -> Proc
-    def self.parse: (untyped val) -> untyped
+    private def self.boolean: () -> Proc
+    private def self.self_referential: () -> Proc
+    private def self.string_class: (String class_name, untyped? context_class) -> Proc
+    private def self.array: (untyped element_type, ?untyped? context_class) -> Proc
+    private def self.parseable: (untyped type) -> Proc
+    private def self.kernel: (Class type) -> Proc
+    private def self.parse: (untyped val) -> untyped
   end
 end

data/sig/structure/version.rbs

@@ -0,0 +1,3 @@
+module Structure
+  VERSION: String
+end

data/sig/structure.rbs

@@ -1,21 +1,12 @@
 module Structure
-  def self.new: () ?{ () [self: Structure::Builder] -> void } -> singleton(Data)
-
-  module ClassMethods
-    def parse: (?(Hash[String | Symbol, untyped] | nil) data, **untyped kwargs) -> instance
-    def members: () -> Array[Symbol]
+  interface _StructuredDataClass
     def __structure_meta__: () -> {
       attributes: Array[Symbol],
       types: Hash[Symbol, untyped],
-      defaults: Hash[Symbol, untyped],
-      from: Hash[Symbol, String]
+      defaults: Hash[Symbol, untyped]
     }
+    def parse: (?Hash[String | Symbol, untyped] data, **untyped kwargs) -> instance
   end
 
-  module InstanceMethods
-    def deconstruct: () -> Array[untyped]
-    def deconstruct_keys: (Array[Symbol]?) -> Hash[Symbol, untyped]
-    def with: (**untyped) -> instance
-    def to_h: () -> Hash[Symbol, untyped]
-  end
+  def self.new: () ?{ (Structure::Builder) [self: Structure::Builder] -> void } -> untyped
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: structure
 version: !ruby/object:Gem::Version
-  version: 3.4.0
+  version: 3.6.0
 platform: ruby
 authors:
 - Hakan Ensari
@@ -24,6 +24,7 @@ files:
 - sig/structure/builder.rbs
 - sig/structure/rbs.rbs
 - sig/structure/types.rbs
+- sig/structure/version.rbs
 licenses:
 - MIT
 metadata: