structure 4.0.0 → 4.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2306964e18c5a78a2241c8c42071fd0a1921fa8c7c54cf210b0825b20607cfca
-  data.tar.gz: c43cf42996e715fe5c1ca1b57bf91ee411405f188382b2d10c0b593a66e90a6f
+  metadata.gz: 74f52e94d4ffd40ad55e291a4ab72c108af572be936ee2d1571fef47699af2cb
+  data.tar.gz: d2ef8dee35e2ea236237d1c34c68bc6877039145553f7e1b16729ea84e3778c4
 SHA512:
-  metadata.gz: 314242bf300d7ec09e1755647d4a8fef224eb2c64fc0b6d945be386b7af008c22146e80993f1e753f1df9cc5b37841242b7ab4a14d71cde42732952e288fc196
-  data.tar.gz: 72dcc21770b4f57b67fd64b8ad69695f02d0a55b2622717f63795b8da32aa8b45cd61db146b2e2c4dc02683588ca74dba831437652afaed9bb25fc159195d0b5
+  metadata.gz: f0c4192ddde552c7cd4a583aca9bdad31aeb64dc039680e965944696ee7648cc9a423017ab8cea5546c708ae72b7920c21fb2c96e74442932f24a3a85faa6b81
+  data.tar.gz: 03d4ea5fda959cd3bcd60b79a323b8dbfaeb5792c22b809179b7f84f76aab36845e7dbcd2f30567cf7922eea9995997cfb730cd69e8dd726cebded2bd076f540

data/lib/structure/rbs.rb

@@ -4,6 +4,10 @@ require "fileutils"
 require "pathname"
 
 module Structure
+  # Generates RBS type signatures for Structure classes
+  #
+  # Note: Custom methods defined in Structure blocks are not included and must be manually added to RBS files. This is
+  # consistent with how Ruby's RBS tooling handles Data classes.
   module RBS
     class << self
       def emit(klass)
@@ -63,50 +67,66 @@ module Structure
             [attr, rbs_type != "untyped" ? "#{rbs_type}?" : rbs_type]
           end.to_h
 
-          # Mark optional attributes with ? prefix in keyword params
-          keyword_params = attributes.map do |attr|
-            prefix = required.include?(attr) ? "" : "?"
-            "#{prefix}#{attr}: #{rbs_types[attr]}"
-          end.join(", ")
+          # Sort keyword params: required first, then optional (with ? prefix)
+          # Within each group, maintain declaration order
+          required_params = required.map { |attr| "#{attr}: #{rbs_types[attr]}" }
+          optional_params = (attributes - required).map { |attr| "?#{attr}: #{rbs_types[attr]}" }
+          keyword_params = (required_params + optional_params).join(", ")
           positional_params = attributes.map { |attr| rbs_types[attr] }.join(", ")
 
-          lines << "  def self.new: (#{keyword_params}) -> #{class_name}"
-          lines << "              | (#{positional_params}) -> #{class_name}"
-          lines << ""
-
           needs_parse_data = types.any? do |_attr, type|
             type == :self || type == [:self]
           end
 
+          # Generate type alias first if needed (RBS::Sorter puts types at top)
           if needs_parse_data
-            lines << "  type parse_data = {"
-            attributes.each do |attr|
+            lines << "  type parse_data = { " + attributes.map { |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 << ""
+              "?#{attr}: #{parse_type}"
+            }.join(", ") + " }"
+          end
+
+          lines << "  def self.new: (#{keyword_params}) -> #{class_name}"
+          lines << "              | (#{positional_params}) -> #{class_name}"
+          lines << ""
+          lines << "  def self.[]: (#{keyword_params}) -> #{class_name}"
+          lines << "             | (#{positional_params}) -> #{class_name}"
+          lines << ""
+
+          # Generate members tuple type
+          members_tuple = attributes.map { |attr| ":#{attr}" }.join(", ")
+          lines << "  def self.members: () -> [ #{members_tuple} ]"
+          lines << ""
+
+          # Generate parse method signatures
+          if needs_parse_data
             lines << "  def self.parse: (?parse_data data) -> #{class_name}"
             lines << "                | (?Hash[String, untyped] data) -> #{class_name}"
           else
-            # For structures without special types, just use Hash
-            lines << "  def self.parse: (?(Hash[String | Symbol, untyped]), **untyped) -> #{class_name}"
+            # Remove optional parentheses to match RBS::Sorter style
+            lines << "  def self.parse: (?Hash[String | Symbol, untyped], **untyped) -> #{class_name}"
           end
           lines << ""
 
-          attributes.each do |attr|
+          # Sort attr_reader lines alphabetically (RBS::Sorter does this)
+          attributes.sort.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?("?")
+          # Add boolean predicates
+          boolean_predicates = types.sort.select { |attr, type| type == :boolean && !attr.to_s.end_with?("?") }
+          unless boolean_predicates.empty?
+            lines << ""
+            boolean_predicates.each do |attr, _type|
               lines << "  def #{attr}?: () -> bool"
             end
           end
 
+          # Instance members method comes after attr_readers and predicates
+          lines << "  def members: () -> [ #{members_tuple} ]"
+          lines << ""
+
           hash_type = attributes.map { |attr| "#{attr}: #{rbs_types[attr]}" }.join(", ")
           lines << "  def to_h: () -> { #{hash_type} }"
         end

data/lib/structure/version.rb

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

data/lib/structure.rb

@@ -26,6 +26,22 @@ module Structure
       # @type var klass: untyped
       klass = Data.define(*builder.attributes)
 
+      # Enable custom method definitions by evaluating block on the class
+      if block
+        # Provide temporary dummy DSL methods to prevent NoMethodError during class_eval
+        klass.define_singleton_method(:attribute) { |*args, **kwargs, &blk| }
+        klass.define_singleton_method(:attribute?) { |*args, **kwargs, &blk| }
+        klass.define_singleton_method(:after_parse) { |&blk| }
+
+        # Evaluate block in class context for method definitions
+        klass.class_eval(&block)
+
+        # Remove temporary DSL methods
+        klass.singleton_class.send(:remove_method, :attribute)
+        klass.singleton_class.send(:remove_method, :attribute?)
+        klass.singleton_class.send(:remove_method, :after_parse)
+      end
+
       # Override initialize to make optional attributes truly optional
       optional_attrs = builder.optional
       unless optional_attrs.empty?

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: structure
 version: !ruby/object:Gem::Version
-  version: 4.0.0
+  version: 4.1.0
 platform: ruby
 authors:
 - Hakan Ensari