structure 3.3.0 → 3.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 69bf1e759bbf993b28fb70235866a6c36774b92a57ee47764458d24bb062a55b
-  data.tar.gz: 3e9a55913e14fb630ece6c4fff62df1d8bfff69d61efd1034a406cf404423f96
+  metadata.gz: 69015a521f4a1a35438cd69d0d195e8f0fa276156d64371c8a6437030b14caf0
+  data.tar.gz: d4e5c263a7c92ae2bfbdbe5213b933c55ea1a8f0c9a8d6583302f8c032bb69a9
 SHA512:
-  metadata.gz: c8b75ee56372f7af3ffd9398474ce25bcffed641314a77293a735cc5e5269f68ee7ba645ed44456eea5c84d1c2b551d0181be35519a61b553466ceda85287f8a
-  data.tar.gz: 3f736db422a6abe5dae0b59d37194d8f2242c2970a506f40efe04b379f00b7cbc14dd2a3437023d0a33bd0d80376f6418c1421659d446c546d56ccbb1352abf5
+  metadata.gz: 1e8ace0197fb9b9cd4811cc1eb7774fe98eff67df140400b567a0a636b9bdabcf2e7858586a7b13f96fbc95e101e2eef74518d9940b1f7c4dab168fec119fb3e
+  data.tar.gz: 9d7fa653f6b4aeb60b10bfca4a940677bee89c6803a8e50d893e9dc0ce687306691bbb6f92f4af0a59c89245c3583e8b6d64f477d27b44b71f0f1b7fc359bb26

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] = Types.coerce(type)
+      else
+        types[name] = type || block
       end
     end
 
@@ -63,13 +60,16 @@ module Structure
       @mappings.keys
     end
 
+    def coercions
+      @types.transform_values { |type| Types.coerce(type) }
+    end
+
     def predicate_methods
-      @types.filter_map do |name, type_lambda|
-        if Types.boolean?(type_lambda) && !name.to_s.end_with?("?")
-          predicate_name = "#{name}?"
-          [predicate_name.to_sym, name]
+      @types.filter_map do |name, type|
+        if type == :boolean
+          ["#{name}?".to_sym, name] unless name.to_s.end_with?("?")
         end
-      end.to_h
+      end.compact.to_h
     end
   end
 end

data/lib/structure/rbs.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "pathname"
+
+module Structure
+  module RBS
+    class << self
+      def emit(klass)
+        return unless klass < Data
+
+        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, {}), # steep:ignore
+          has_structure_modules: meta.any?,
+        )
+      end
+
+      def write(klass, dir: "sig")
+        rbs_content = emit(klass)
+        return unless rbs_content
+
+        # User::Address -> user/address.rbs
+        path_segments = klass.name.split("::").map(&:downcase)
+        filename = "#{path_segments.pop}.rbs"
+
+        # full path
+        dir_path = Pathname.new(dir)
+        dir_path = dir_path.join(*path_segments) unless path_segments.empty?
+        FileUtils.mkdir_p(dir_path)
+
+        file_path = dir_path.join(filename).to_s
+        File.write(file_path, rbs_content)
+
+        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"
+
+        unless attributes.empty?
+          # map types to rbs
+          rbs_types = attributes.map do |attr|
+            type = types.fetch(attr, nil)
+            rbs_type = map_type_to_rbs(type, class_name)
+
+            [attr, rbs_type != "untyped" ? "#{rbs_type}?" : rbs_type]
+          end.to_h
+
+          keyword_params = attributes.map { |attr| "#{attr}: #{rbs_types[attr]}" }.join(", ")
+          positional_params = attributes.map { |attr| rbs_types[attr] }.join(", ")
+
+          lines << "  def self.new: (#{keyword_params}) -> instance"
+          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
+          lines << ""
+
+          types.each do |attr, type|
+            if type == :boolean && !attr.to_s.end_with?("?")
+              lines << "  def #{attr}?: () -> bool"
+            end
+          end
+
+          hash_type = attributes.map { |attr| "#{attr}: #{rbs_types[attr]}" }.join(", ")
+          lines << "  def to_h: () -> { #{hash_type} }"
+        end
+
+        lines << "end"
+        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
+          type.name || "untyped"
+        when :boolean
+          "bool"
+        when :self
+          class_name || "untyped"
+        when Array
+          if type.size == 2 && type.first == :array
+            element_type = map_type_to_rbs(type.last, class_name)
+            "Array[#{element_type}]"
+          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
+        else
+          "untyped"
+        end
+      end
+    end
+  end
+end

data/lib/structure/types.rb

@@ -3,81 +3,88 @@
 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
-
-    def boolean?(type)
-      type == boolean
-    end
-
-    # 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)
-        else
-          type
-        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)
+      # 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)
+          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
       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 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)
+        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
+        else
+          element_coercer = coerce(element_type)
+          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.3.0"
+  VERSION = "3.5.0"
 end

data/lib/structure.rb

@@ -23,78 +23,96 @@ module Structure
       builder = Builder.new
       builder.instance_eval(&block) if block
 
-      data_class = Data.define(*builder.attributes)
+      # @type var klass: untyped
+      klass = Data.define(*builder.attributes)
 
-      # Generate predicate methods
-      builder.predicate_methods.each do |predicate_name, attribute_name|
-        data_class.define_method(predicate_name) do
-          send(attribute_name)
-        end
-      end
+      # capture metadata and attach to class
+      meta = {
+        attributes: builder.attributes.freeze,
+        types: builder.types.freeze,
+        defaults: builder.defaults.freeze,
+      }.freeze
+      klass.instance_variable_set(:@__structure_meta__, meta)
+      klass.singleton_class.attr_reader(:__structure_meta__)
 
-      # Capture builder data in closure for parse method
+      # capture locals for method generation
       mappings = builder.mappings
-      types = builder.types
-      defaults = builder.defaults
-      attributes = builder.attributes
-      after_parse_callback = builder.after_parse_callback
-
-      # Override to_h to recursively convert nested objects with to_h
-      data_class.define_method(:to_h) do
-        result = {}
-        self.class.members.each do |member|
-          value = send(member)
-          result[member] = case value
-          when Array
-            value.map { |item| item.respond_to?(:to_h) && item ? item.to_h : item }
-          when Hash
-            value
-          when ->(v) { v.respond_to?(:to_h) && v }
-            value.to_h
-          else
-            value
-          end
+      coercions = builder.coercions
+      predicates = builder.predicate_methods
+      after = builder.after_parse_callback
+
+      # Define predicate methods
+      predicates.each do |pred, attr|
+        klass.define_method(pred) { public_send(attr) }
+      end
+
+      # recursive to_h
+      klass.define_method(:to_h) do
+        # @type var h: Hash[Symbol, untyped]
+        h = {}
+        klass.members.each do |m|
+          v = public_send(m)
+          h[m] =
+            case v
+            when Array then v.map { |x| x.respond_to?(:to_h) && x ? x.to_h : x }
+            when ->(x) { x.respond_to?(:to_h) && x } then v.to_h
+            else v
+            end
         end
-        result
+        h
       end
 
-      data_class.define_singleton_method(:parse) do |data = {}, **kwargs|
-        # Merge kwargs into data - kwargs take priority as overrides
-        # Convert kwargs symbol keys to strings to match source_key lookups
+      # parse accepts JSON-ish hashes + kwargs override
+      klass.define_singleton_method(:parse) do |data = {}, **kwargs|
+        return data if data.is_a?(self)
+
+        unless data.respond_to?(:merge!)
+          raise TypeError, "can't convert #{data.class} into #{self}"
+        end
+
+        # @type var kwargs: Hash[Symbol, untyped]
         string_kwargs = kwargs.transform_keys(&:to_s)
-        data = data.merge(string_kwargs)
+        data.merge!(string_kwargs)
+        # @type self: singleton(Data) & _StructuredDataClass
+        # @type var final: Hash[Symbol, untyped]
+        final = {}
 
-        final_kwargs = {}
-        attributes.each do |attr|
-          source_key = mappings[attr]
-          value = if data.key?(source_key)
-            data[source_key]
-          elsif data.key?(source_key.to_sym)
-            data[source_key.to_sym]
-          elsif defaults.key?(attr)
-            defaults[attr]
-          end
+        # 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__
 
-          # Apply type coercion or transformation
-          if types[attr] && !value.nil?
-            type_or_proc = types[attr]
-            # Use instance_exec for non-lambda procs (self-referential types)
-            value = if type_or_proc.is_a?(Proc) && !type_or_proc.lambda?
-              instance_exec(value, &type_or_proc)
-            else
-              type_or_proc.call(value)
+        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 defaults.key?(attr) then defaults[attr]
             end
+
+          coercion = coercions[attr]
+          if coercion && !value.nil?
+            # self-referential types need class context to call parse
+            value =
+              if coercion.is_a?(Proc) && !coercion.lambda?
+                instance_exec(value, &coercion) # steep:ignore
+              else
+                coercion.call(value)
+              end
           end
 
-          final_kwargs[attr] = value
+          final[attr] = value
         end
 
-        instance = new(**final_kwargs)
-        after_parse_callback&.call(instance)
-        instance
+        obj = new(**final)
+        after&.call(obj)
+        obj
       end
 
-      data_class
+      klass
     end
   end
 end

data/sig/structure/builder.rbs

@@ -0,0 +1,21 @@
+module Structure
+  class Builder
+    @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
+
+    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 predicate_methods: () -> Hash[Symbol, Symbol]
+    def after_parse_callback: () -> (Proc | nil)
+  end
+end

data/sig/structure/rbs.rbs

@@ -0,0 +1,10 @@
+module Structure
+  module RBS
+    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
+    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

@@ -0,0 +1,16 @@
+module Structure
+  module Types
+    BOOLEAN_TRUTHY: Array[untyped]
+
+    self.@boolean: Proc
+
+    def self.coerce: (untyped type) -> untyped
+
+    private def self.boolean: () -> Proc
+    private def self.self_referential: () -> Proc
+    private def self.array: (untyped type) -> 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

@@ -0,0 +1,12 @@
+module Structure
+  interface _StructuredDataClass
+    def __structure_meta__: () -> {
+      attributes: Array[Symbol],
+      types: Hash[Symbol, untyped],
+      defaults: Hash[Symbol, untyped]
+    }
+    def parse: (?Hash[String | Symbol, untyped] data, **untyped kwargs) -> instance
+  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.3.0
+  version: 3.5.0
 platform: ruby
 authors:
 - Hakan Ensari
@@ -17,8 +17,14 @@ extra_rdoc_files: []
 files:
 - lib/structure.rb
 - lib/structure/builder.rb
+- lib/structure/rbs.rb
 - lib/structure/types.rb
 - lib/structure/version.rb
+- sig/structure.rbs
+- sig/structure/builder.rbs
+- sig/structure/rbs.rbs
+- sig/structure/types.rbs
+- sig/structure/version.rbs
 licenses:
 - MIT
 metadata: