structure 3.3.0 → 3.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 69bf1e759bbf993b28fb70235866a6c36774b92a57ee47764458d24bb062a55b
-  data.tar.gz: 3e9a55913e14fb630ece6c4fff62df1d8bfff69d61efd1034a406cf404423f96
+  metadata.gz: 2a7bd562939e000315d1904c5f766c0293c570413aa69930e522a01e70849715
+  data.tar.gz: '0649cee7d47286ad9ba6e36721cc350f20a9ba40c971214e0edb91bde8bec7d9'
 SHA512:
-  metadata.gz: c8b75ee56372f7af3ffd9398474ce25bcffed641314a77293a735cc5e5269f68ee7ba645ed44456eea5c84d1c2b551d0181be35519a61b553466ceda85287f8a
-  data.tar.gz: 3f736db422a6abe5dae0b59d37194d8f2242c2970a506f40efe04b379f00b7cbc14dd2a3437023d0a33bd0d80376f6418c1421659d446c546d56ccbb1352abf5
+  metadata.gz: 3d09a3983e553ccbf3f031c2bb2f920b430032ee5d778b1572f9423e2593808e458662f77615fc84a002136b0896a7bfb5ceff0119d880df1fc833f4123dd493
+  data.tar.gz: ec6da8a717b8ccab314c808bb9ab3218d733790378f3b61dbdf52dffbf4b28fd7fd7d6ae7b484d390809a8396fccd894b0d087a3d1a90926149bc55db5a98848

data/lib/structure/builder.rb

@@ -42,7 +42,7 @@ module Structure
       elsif block
         @types[name] = block
       elsif type
-        @types[name] = Types.coerce(type)
+        @types[name] = type
       end
     end
 
@@ -63,13 +63,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,111 @@
+# 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
+
+        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, {}),
+          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)
+        File.write(file_path, rbs_content)
+
+        file_path.to_s
+      end
+
+      private
+
+      def emit_rbs_content(class_name:, attributes:, types:, has_structure_modules:)
+        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
+          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 << ""
+
+          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 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 == [:self]
+            "Array[#{class_name || "untyped"}]"
+          else
+            "untyped"
+          end
+        else
+          "untyped"
+        end
+      end
+    end
+  end
+end

data/lib/structure/types.rb

@@ -10,10 +10,6 @@ module Structure
     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

data/lib/structure/version.rb

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

data/lib/structure.rb

@@ -23,78 +23,80 @@ module Structure
       builder = Builder.new
       builder.instance_eval(&block) if block
 
-      data_class = Data.define(*builder.attributes)
+      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
+      coercions = builder.coercions
+      predicates = builder.predicate_methods
+      after = 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
+      # 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
+        #: Hash[Symbol, untyped]
+        self.class.members.each_with_object({}) do |m, h|
+          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
       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|
         string_kwargs = kwargs.transform_keys(&:to_s)
         data = data.merge(string_kwargs)
 
-        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
+        #: Hash[Symbol, untyped]
+        final = {}
+        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)
+        meta[: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]
             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)
+              else
+                coercion.call(value)
+              end
           end
 
-          final_kwargs[attr] = value
+          final[attr] = value
         end
 
-        instance = new(**final_kwargs)
-        after_parse_callback&.call(instance)
-        instance
+        #: untyped
+        obj = new(**final)
+        after&.call(obj)
+        obj
       end
 
-      data_class
+      klass
     end
   end
 end

data/sig/structure/builder.rbs

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

data/sig/structure/rbs.rbs

@@ -0,0 +1,11 @@
+module Structure
+  module RBS
+    def self.emit: (Class klass) -> String?
+    def self.write: (Class 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
+  end
+end

data/sig/structure/types.rbs

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

data/sig/structure.rbs

@@ -0,0 +1,21 @@
+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]
+    def __structure_meta__: () -> {
+      attributes: Array[Symbol],
+      types: Hash[Symbol, untyped],
+      defaults: Hash[Symbol, untyped],
+      from: Hash[Symbol, String]
+    }
+  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
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: structure
 version: !ruby/object:Gem::Version
-  version: 3.3.0
+  version: 3.4.0
 platform: ruby
 authors:
 - Hakan Ensari
@@ -17,8 +17,13 @@ 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
 licenses:
 - MIT
 metadata: