mortymer 0.0.10 → 0.0.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8c49e9b245a1153aff2fe7a3e8dfe0a4c9bfd60946508bb5370ecc2a9bd40fdd
-  data.tar.gz: a3ef9f90da8ed2201b0a14d93fef1a71b4c4219bf46a9df92354e2537291fc48
+  metadata.gz: 1aaae1b0260575ca60caeb8b676577f39766162d8127a6266e1c49e168e11265
+  data.tar.gz: 0f92cfaa12e157dcb4954259dd284b7b46f7305dd912d84a55fef597107997f7
 SHA512:
-  metadata.gz: 589b5dfd53e5aff161283d4bebff4aaa3d33d6c801500898e5042017a6520fa78933ddf473cd6396ee34938fcc4e264b6c825c0b42a3066cc5fa672793cafcc2
-  data.tar.gz: 9770e1bcd6a3d334c62864a144802cf6523e8713aafd57f7d25d81b9f6341221e22107cbacdfce8c6330f6b83b6ad7b4155878fd21b00bead97236e8d4d2aae5
+  metadata.gz: c5c3932bfb5b0daf315af6f8f4a1ef36b0a448229fd15b9c71f7c8699d8f41fcfeb8a5858686b55d6c7905628936908512e97537b6a5ec0024061f6b3f4bcd60
+  data.tar.gz: df393725ff3c29b36ede225c046f8f27cbfea156f09917cd1976b8c3188f9dafa5e57e0aa0876a378f7afda62ab0ea06b17f500d0f46f6d8caae18c249c13acf

data/lib/mortymer/contract.rb

@@ -4,11 +4,14 @@ require_relative "moldeable"
 require "dry/validation"
 require "dry/validation/contract"
 require_relative "generator"
+require_relative "types"
+require_relative "struct_compiler"
 
 module Mortymer
   # A base model for defining schemas
   class Contract < Dry::Validation::Contract
     include Mortymer::Moldeable
+    include Mortymer::Types
 
     # Exception raised when an error occours in a contract
     class ContractError < StandardError
@@ -20,15 +23,28 @@ module Mortymer
       end
     end
 
+    def self.__internal_struct_repr__
+      @__internal_struct_repr__ || StructCompiler.new.compile(schema.json_schema)
+    end
+
     def self.json_schema
       Generator.new.from_validation(self)
     end
 
     def self.structify(params)
       result = new.call(params)
-      raise ContractError.new(result.errors.to_h) unless result.errors.empty?
+      raise ContractError, result.errors.to_h unless result.errors.empty?
+
+      __internal_struct_repr__.new(**result.to_h)
+    end
 
-      result.to_h
+    def self.compile!
+      # Force eager compilation of the internal struct representation.
+      # This provides an optimization by precompiling the struct when
+      # the class is defined rather than waiting for the first use.
+      # The compilation result is memoized, so subsequent accesses
+      # will reuse the compiled struct.
+      __internal_struct_repr__
     end
   end
 end

data/lib/mortymer/model.rb

@@ -9,14 +9,14 @@ module Mortymer
   # A base model for defining schemas
   class Model < Dry::Struct
     include Mortymer::Moldeable
-    include Dry.Types()
+    include Mortymer::Types
 
     def self.json_schema
       Generator.new.from_struct(self)
     end
 
     def self.structify(params)
-      new(params)
+      call(params)
     end
   end
 end

data/lib/mortymer/sigil.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Mortymer
+  # Sigil provides symbolic type checking for input and outputs
+  # of method calls using dry-types
+  module Sigil
+    class TypeError < StandardError; end
+
+    # Class methods to be included as part of the dsl
+    module ClassMethods
+      # Store type signatures for methods before they are defined
+      def sign(*positional_types, returns: nil, **keyword_types)
+        @pending_type_signature = {
+          positional_types: positional_types,
+          keyword_types: keyword_types,
+          returns: returns
+        }
+      end
+
+      # Hook called when a method is defined
+      def method_added(method_name)
+        return super if @pending_type_signature.nil?
+        return super if @processing_type_check
+
+        signature = @pending_type_signature
+        @pending_type_signature = nil
+
+        # Get the original method
+        original_method = instance_method(method_name)
+
+        @processing_type_check = true
+
+        # Redefine the method with type checking
+        define_method(method_name) do |*args, **kwargs|
+          # Validate positional arguments
+          procced_args = []
+          procced_kwargs = {}
+          args.each_with_index do |arg, idx|
+            unless (type = signature[:positional_types][idx])
+              procced_args << arg
+              next
+            end
+
+            begin
+              procced_args << (type.respond_to?(:structify) ? type.structify(arg) : type.call(arg))
+            rescue Dry::Types::CoercionError => e
+              raise TypeError, "Invalid type for argument #{idx}: expected #{type}, got #{arg.class} - #{e.message}"
+            end
+          end
+
+          # Validate keyword arguments
+          kwargs.each do |key, value|
+            unless (type = signature[:keyword_types][key])
+              procced_kwargs[key] = value
+              next
+            end
+
+            begin
+              procced_kwargs[key] = (type.respond_to?(:structify) ? type.structify(value) : type.call(value))
+            rescue Dry::Types::CoercionError => e
+              raise TypeError,
+                    "Invalid type for keyword argument #{key}: expected #{type}, got #{value.class} - #{e.message}"
+            end
+          end
+
+          # Call the original method
+          result = original_method.bind(self).call(*procced_args, **procced_kwargs)
+
+          # Validate return type if specified
+          if (return_type = signature[:returns])
+            begin
+              return return_type.respond_to?(:structify) ? return_type.structify(result) : return_type.call(result)
+            rescue Dry::Types::CoercionError => e
+              raise TypeError, "Invalid return type: expected #{return_type}, got #{result.class} - #{e.message}"
+            end
+          end
+
+          result
+        end
+
+        @processing_type_check = false
+
+        # Call super to maintain compatibility with other method hooks
+        super
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+  end
+end

data/lib/mortymer/struct_compiler.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require "dry-struct"
+require "securerandom"
+
+module Mortymer
+  class StructCompiler
+    PRIMITIVE_TYPE_MAP = {
+      "string" => Mortymer::Model::String,
+      "integer" => Mortymer::Model::Integer,
+      "number" => Mortymer::Model::Float,
+      "boolean" => Mortymer::Model::Bool,
+      "null" => Mortymer::Model::Nil,
+      string: Mortymer::Model::String,
+      integer: Mortymer::Model::Integer,
+      number: Mortymer::Model::Float,
+      boolean: Mortymer::Model::Bool,
+      null: Mortymer::Model::Nil
+    }.freeze
+
+    def initialize(class_name = "GeneratedStruct#{SecureRandom.hex(4)}")
+      @class_name = class_name
+      @types = {}
+    end
+
+    def compile(schema)
+      build_type(schema, @class_name)
+    end
+
+    private
+
+    def build_type(schema, type_name)
+      schema = normalize_schema(schema)
+      case schema["type"]
+      when "object"
+        build_object_type(schema, type_name)
+      when "array"
+        build_array_type(schema)
+      else
+        build_primitive_type(schema)
+      end
+    end
+
+    def normalize_schema(schema)
+      return {} if schema.nil?
+
+      schema = schema.transform_keys(&:to_s)
+      if schema["properties"]
+        schema["properties"] = schema["properties"].transform_keys(&:to_s)
+        schema["properties"].each_value do |prop_schema|
+          normalize_schema(prop_schema)
+        end
+      end
+      schema["items"] = normalize_schema(schema["items"]) if schema["items"]
+      schema["required"] = schema["required"].map(&:to_s) if schema["required"]
+      if schema["enum"]
+        schema["enum"] = schema["enum"].map { |v| v.is_a?(Symbol) ? v.to_s : v }
+      end
+      schema
+    end
+
+    def build_object_type(schema, type_name)
+      return {} unless schema["properties"]
+
+      # Build attribute definitions
+      attributes = schema["properties"].map do |name, property_schema|
+        name = name.to_s # Ensure name is a string
+        nested_type_name = camelize("#{type_name}#{camelize(name)}")
+        type = if property_schema["type"] == "object"
+                 build_type(property_schema, nested_type_name)
+               else
+                 build_type(property_schema, nil)
+               end
+
+        required = schema["required"]&.include?(name)
+        [name, required ? type : type.optional, required]
+      end
+
+      # Create a new Struct class for this object
+      Class.new(Mortymer::Model) do
+        attributes.each do |name, type, required|
+          if required
+            attribute name.to_sym, type
+          else
+            attribute? name.to_sym, type
+          end
+        end
+      end
+    end
+
+    def build_array_type(schema)
+      item_type = build_type(schema["items"], nil)
+      Mortymer::Model::Array.of(item_type)
+    end
+
+    def build_primitive_type(schema)
+      type_class = PRIMITIVE_TYPE_MAP[schema["type"]] || Mortymer::Model::Any
+
+      if schema["enum"]
+        type_class.enum(*schema["enum"])
+      else
+        type_class
+      end
+    end
+
+    def camelize(string)
+      string.split(/[^a-zA-Z0-9]/).map(&:capitalize).join
+    end
+  end
+end

data/lib/mortymer/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Mortymer
-  VERSION = "0.0.10"
+  VERSION = "0.0.11"
 end

data/lib/mortymer.rb

@@ -2,6 +2,8 @@
 # typed: true
 
 require "dry/struct"
+require "dry/schema"
+Dry::Schema.load_extensions(:json_schema)
 require "mortymer/types"
 require "mortymer/uploaded_file"
 require "mortymer/uploaded_files"
@@ -18,5 +20,7 @@ require "mortymer/openapi_generator"
 require "mortymer/container"
 require "mortymer/dependencies_dsl"
 require "mortymer/security_schemes"
+require "mortymer/struct_compiler"
+require "mortymer/sigil"
 require "mortymer/rails" if defined?(Rails)
 require "mortymer/railtie" if defined?(Rails::Railtie)

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: mortymer
 version: !ruby/object:Gem::Version
-  version: 0.0.10
+  version: 0.0.11
 platform: ruby
 authors:
 - Adrian Gonzalez
 bindir: exe
 cert_chain: []
-date: 2025-03-24 00:00:00.000000000 Z
+date: 2025-03-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-struct
@@ -115,6 +115,8 @@ files:
 - lib/mortymer/rails/routes.rb
 - lib/mortymer/railtie.rb
 - lib/mortymer/security_schemes.rb
+- lib/mortymer/sigil.rb
+- lib/mortymer/struct_compiler.rb
 - lib/mortymer/types.rb
 - lib/mortymer/uploaded_file.rb
 - lib/mortymer/uploaded_files.rb