structure 4.3.0 → 4.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f9c2544c619e8f11dcafb8765dd9ebfee9c931927bf71d44aed73c7640d98915
-  data.tar.gz: 6156fbc60895981a25c1a5816fcdb6c367855552ac6a1397f19a7c22b602761c
+  metadata.gz: 70c0f08018c0b2adccf83a0fd310719e21e79e2f0945d753fef9df5a08226537
+  data.tar.gz: e62bbdc33e63db5845d816ba84bbde60433e4137d95a7466dbbcd1376891eccf
 SHA512:
-  metadata.gz: '09728c8023e6d0102df31ab627d76e98aa6212a14dc7d98151f24dadeb7a46ff12c796a2990bb27a69fa78828dfe1b451669d3547041c3da2175d9dbb6bfebb4'
-  data.tar.gz: ee06e66c737f47ecc9c18a17470b995c6b5abe0c7708e875fbcb11e9b718371eea991d76aa6b31d2695048fc2203fb06b7d91258c8031b747e111b1fed907a9a
+  metadata.gz: 4acad52488ad58e454cf052b14727aa70f75bfb921ee5ffb92310287194b2be4019caa98c5afd995df64a9a6356eafde4f6ffcb33680dc504355a79c575ba801
+  data.tar.gz: 9ed2e262bdf3488c5b074b9b1e8148049908883a92deaec90cd969715ff34879231017bbe7061b0a6d3ac9c812dc999497884f383754987e7bee9a64661e0027

data/lib/structure/builder.rb

@@ -68,7 +68,7 @@ module Structure
     # @example Optional with default
     #   attribute? :status, String, default: "pending"
     #
-    # @example Optional but non-nullable when present
+    # @example Optional but non-nullable when present (e.g. GraphQL String!)
     #   attribute? :name, String, null: false
     def attribute?(name, type = nil, from: nil, default: nil, null: true, &block)
       attribute(name, type, from: from, default: default, null: null, &block)

data/lib/structure/rbs.rb

@@ -28,6 +28,7 @@ module Structure
         types = meta.fetch(:types, default_types)
         # @type var required: Array[Symbol]
         required = meta.fetch(:required, attributes)
+        non_nullable = meta.fetch(:non_nullable, [])
         custom_methods = meta.fetch(:custom_methods, EMPTY_CUSTOM_METHODS)
 
         emit_rbs_content(
@@ -35,6 +36,7 @@ module Structure
           attributes:,
           types:,
           required:,
+          non_nullable:,
           has_structure_modules: meta.any?,
           custom_methods:,
         )
@@ -59,9 +61,33 @@ module Structure
         file_path
       end
 
+      # Write RBS files for multiple classes or all Structure classes in a module
+      #
+      # @param classes [Array<Class>, Module] Classes to generate RBS for, or a module to scan
+      # @param dir [String] Output directory (default: "sig")
+      # @return [Array<String>] Paths of written RBS files
+      #
+      # @example With array of classes
+      #   Structure::RBS.write_all([Person, Address, Order])
+      #
+      # @example With module namespace
+      #   Structure::RBS.write_all(Peddler::Models)
+      def write_all(classes, dir: "sig")
+        classes = structure_classes_in(classes) if classes.is_a?(Module)
+
+        classes.filter_map { |klass| write(klass, dir: dir) }
+      end
+
       private
 
-      def emit_rbs_content(class_name:, attributes:, types:, required:, has_structure_modules:, custom_methods:)
+      def structure_classes_in(mod)
+        mod.constants.filter_map do |const_name|
+          const = mod.const_get(const_name)
+          const if const.is_a?(Class) && const < Data && const.respond_to?(:__structure_meta__)
+        end
+      end
+
+      def emit_rbs_content(class_name:, attributes:, types:, required:, non_nullable:, has_structure_modules:, custom_methods:)
         # @type var lines: Array[String]
         lines = []
         lines << "class #{class_name} < Data"
@@ -71,8 +97,9 @@ module Structure
           rbs_types = attributes.map do |attr|
             type = types.fetch(attr, nil)
             rbs_type = map_type_to_rbs(type, class_name)
+            nullable = !(required.include?(attr) && non_nullable.include?(attr))
 
-            [attr, rbs_type != "untyped" ? "#{rbs_type}?" : rbs_type]
+            [attr, rbs_type != "untyped" && nullable ? "#{rbs_type}?" : rbs_type]
           end.to_h
 
           # Sort keyword params: required first, then optional (with ? prefix)

data/lib/structure/version.rb

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

data/lib/tapioca/dsl/compilers/structure.rb

@@ -0,0 +1,200 @@
+# typed: strict
+# frozen_string_literal: true
+
+return unless defined?(Tapioca::Dsl::Compiler)
+
+module Tapioca
+  module Dsl
+    module Compilers
+      # Generates RBI files for Structure-based Data classes.
+      #
+      # For example, given:
+      #
+      #   Person = Structure.new do
+      #     attribute :name, String
+      #     attribute? :age, Integer
+      #   end
+      #
+      # This compiler will generate:
+      #
+      #   class Person < Data
+      #     sig { params(name: String, age: T.nilable(Integer)).returns(Person) }
+      #     sig { params(name: String, age: T.nilable(Integer)).void }
+      #     def initialize(name:, age: nil); end
+      #
+      #     sig { returns(String) }
+      #     def name; end
+      #
+      #     sig { returns(T.nilable(Integer)) }
+      #     def age; end
+      #
+      #     sig { params(data: T::Hash[T.any(String, Symbol), T.untyped]).returns(Person) }
+      #     def self.parse(data = {}); end
+      #   end
+      #: [ConstantType = singleton(::Data)]
+      class Structure < Compiler
+        extend T::Sig
+
+        class << self
+          extend T::Sig
+
+          sig { override.returns(T::Enumerable[Module]) }
+          def gather_constants
+            all_classes.select do |klass|
+              klass < ::Data && klass.respond_to?(:__structure_meta__)
+            end
+          end
+        end
+
+        sig { override.void }
+        def decorate
+          meta = constant.__structure_meta__
+          return unless meta
+
+          attributes = meta[:mappings]&.keys || constant.members
+          types = meta.fetch(:types, {})
+          required = meta.fetch(:required, attributes)
+          non_nullable = meta.fetch(:non_nullable, [])
+
+          root.create_path(constant) do |klass|
+            generate_new_and_brackets(klass, attributes, types, required, non_nullable)
+            generate_parse(klass)
+            generate_load_dump(klass)
+            generate_members(klass, attributes)
+            generate_attr_readers(klass, attributes, types, non_nullable, required)
+            generate_to_h(klass, attributes, types, non_nullable, required)
+            generate_boolean_predicates(klass, types)
+          end
+        end
+
+        private
+
+        sig { params(klass: RBI::Scope, attributes: T::Array[Symbol], types: T::Hash[Symbol, T.untyped], required: T::Array[Symbol], non_nullable: T::Array[Symbol]).void }
+        def generate_new_and_brackets(klass, attributes, types, required, non_nullable)
+          params = attributes.map do |attr|
+            type = map_type_to_sorbet(types[attr], nullable: !(required.include?(attr) && non_nullable.include?(attr)))
+            is_required = required.include?(attr)
+            if is_required
+              create_kw_param(attr.to_s, type: type)
+            else
+              create_kw_opt_param(attr.to_s, type: type, default: "nil")
+            end
+          end
+
+          klass.create_method("initialize", parameters: params, return_type: "void")
+          klass.create_method("new", parameters: params, return_type: constant.name.to_s, class_method: true)
+          klass.create_method("[]", parameters: params, return_type: constant.name.to_s, class_method: true)
+        end
+
+        sig { params(klass: RBI::Scope).void }
+        def generate_parse(klass)
+          klass.create_method(
+            "parse",
+            parameters: [
+              create_opt_param("data", type: "T::Hash[T.any(String, Symbol), T.untyped]", default: "{}"),
+              create_opt_param("overrides", type: "T.nilable(T::Hash[Symbol, T.untyped])", default: "nil"),
+            ],
+            return_type: constant.name.to_s,
+            class_method: true,
+          )
+        end
+
+        sig { params(klass: RBI::Scope).void }
+        def generate_load_dump(klass)
+          klass.create_method(
+            "load",
+            parameters: [create_param("data", type: "T.nilable(T::Hash[T.any(String, Symbol), T.untyped])")],
+            return_type: "T.nilable(#{constant.name})",
+            class_method: true,
+          )
+          klass.create_method(
+            "dump",
+            parameters: [create_param("value", type: "T.nilable(#{constant.name})")],
+            return_type: "T.nilable(T::Hash[Symbol, T.untyped])",
+            class_method: true,
+          )
+        end
+
+        sig { params(klass: RBI::Scope, attributes: T::Array[Symbol]).void }
+        def generate_members(klass, attributes)
+          members_type = "[#{attributes.map { |a| ":#{a}" }.join(", ")}]"
+          klass.create_method("members", return_type: members_type, class_method: true)
+          klass.create_method("members", return_type: members_type)
+        end
+
+        sig { params(klass: RBI::Scope, attributes: T::Array[Symbol], types: T::Hash[Symbol, T.untyped], non_nullable: T::Array[Symbol], required: T::Array[Symbol]).void }
+        def generate_attr_readers(klass, attributes, types, non_nullable, required)
+          attributes.each do |attr|
+            type = map_type_to_sorbet(types[attr], nullable: !(required.include?(attr) && non_nullable.include?(attr)))
+            klass.create_method(attr.to_s, return_type: type)
+          end
+        end
+
+        sig { params(klass: RBI::Scope, attributes: T::Array[Symbol], types: T::Hash[Symbol, T.untyped], non_nullable: T::Array[Symbol], required: T::Array[Symbol]).void }
+        def generate_to_h(klass, attributes, types, non_nullable, required)
+          hash_pairs = attributes.map do |attr|
+            type = map_type_to_sorbet(types[attr], nullable: !(required.include?(attr) && non_nullable.include?(attr)))
+            "#{attr}: #{type}"
+          end.join(", ")
+
+          klass.create_method("to_h", return_type: "{ #{hash_pairs} }")
+        end
+
+        sig { params(klass: RBI::Scope, types: T::Hash[Symbol, T.untyped]).void }
+        def generate_boolean_predicates(klass, types)
+          types.each do |attr, type|
+            next unless type == :boolean
+            next if attr.to_s.end_with?("?")
+
+            klass.create_method("#{attr}?", return_type: "T::Boolean")
+          end
+        end
+
+        sig { params(type: T.untyped, nullable: T::Boolean).returns(String) }
+        def map_type_to_sorbet(type, nullable: true)
+          raw = case type
+          when Class
+            if type == Array
+              "T::Array[T.untyped]"
+            elsif type == Hash
+              "T::Hash[T.untyped, T.untyped]"
+            else
+              type.name || "T.untyped"
+            end
+          when :boolean
+            "T::Boolean"
+          when :self
+            constant.name.to_s
+          when Array
+            if type.size == 1
+              element_type = map_type_to_sorbet_element(type.first)
+              "T::Array[#{element_type}]"
+            else
+              "T.untyped"
+            end
+          when Proc
+            "T.untyped"
+          else
+            "T.untyped"
+          end
+
+          nullable ? "T.nilable(#{raw})" : raw
+        end
+
+        sig { params(type: T.untyped).returns(String) }
+        def map_type_to_sorbet_element(type)
+          case type
+          when Class
+            type.name || "T.untyped"
+          when :boolean
+            "T::Boolean"
+          when :self
+            constant.name.to_s
+          else
+            "T.untyped"
+          end
+        end
+      end
+    end
+  end
+end

data/sig/structure/rbs.rbs

@@ -4,8 +4,10 @@ module Structure
 
     def self.emit: (untyped klass) -> String?
     def self.write: (untyped klass, ?dir: String) -> String?
+    def self.write_all: (Array[untyped] | Module classes, ?dir: String) -> Array[String]
 
-    private def self.emit_rbs_content: (class_name: String, attributes: Array[Symbol], types: Hash[Symbol, untyped], required: Array[Symbol], has_structure_modules: bool, custom_methods: untyped) -> String
+    private def self.structure_classes_in: (Module mod) -> Array[untyped]
+    private def self.emit_rbs_content: (class_name: String, attributes: Array[Symbol], types: Hash[Symbol, untyped], required: Array[Symbol], non_nullable: Array[Symbol], has_structure_modules: bool, custom_methods: untyped) -> 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
     private def self.format_method_signature: (Hash[Symbol, untyped] method_meta, singleton: bool) -> String

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: structure
 version: !ruby/object:Gem::Version
-  version: 4.3.0
+  version: 4.4.0
 platform: ruby
 authors:
 - Hakan Ensari
@@ -20,6 +20,7 @@ files:
 - lib/structure/rbs.rb
 - lib/structure/types.rb
 - lib/structure/version.rb
+- lib/tapioca/dsl/compilers/structure.rb
 - sig/structure.rbs
 - sig/structure/builder.rbs
 - sig/structure/rbs.rbs
@@ -43,7 +44,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.7.2
+rubygems_version: 4.0.3
 specification_version: 4
 summary: Structure your data
 test_files: []