mortymer 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 606d2fd534d7531323c1adee46efd762573215d489f63e21073da23041f8e606
-  data.tar.gz: 00efc44568436fda66af77e8d3b46527e72d95827d8632e2a5c84cde598345a3
+  metadata.gz: 7a6f89fe53efef1f0307aa8a123827de3179bb00b9bde0dea02900773f3d346f
+  data.tar.gz: 439f37ea7091f81186fccc64746fa6ba7392dd06cd46fd24f01da917a4b643cd
 SHA512:
-  metadata.gz: cce8ddc9faa57ddebf4c86cd236df5c673927691ff4f84f3b33b61bd96c32d364d2620ad8e5789ed3b737a79d1b59dd105c8b6eff498466b875c47fdc72b505e
-  data.tar.gz: deb03b69691c693b2fdc7226502ad22af06a12d8eeb291c35bcfb08ad12594a36e215b9f459ddcf80de54c9a5ec51b868486976b925040184d90ea6696026596
+  metadata.gz: 45790ce281ff50fe565f3ae62fdac1d8727cbe84bdc5fa29e17925ec8dcf795eeae9ebaf5055346e88e4dd590c8dca1d5fd8fb1a6711f92eda594413abad9dcf
+  data.tar.gz: 7dc98a3c699f4573cbf826ed7f37546d02ec5eb5434954f78066f2436af792f4f8f109be48b7d6502e980361bdf9c68e30aa8ab2c746087ffc2b4358a1a3bd6b

data/lib/mortymer/configuration.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Mortymer
+  class << self
+    def configure
+      yield(config)
+    end
+
+    def container
+      yield(config.container) if block_given?
+      config.container
+    end
+
+    def config
+      @config ||= Configuration.new
+    end
+  end
+
+  # Global configuration for Mortymer
+  class Configuration
+    attr_accessor :container, :serve_swagger, :swagger_title, :swagger_path, :swagger_root, :api_version,
+                  :api_description
+
+    def initialize
+      @container = Mortymer::Container.new
+      @serve_swagger = true
+      @swagger_title = "Rick & Rails API"
+      @swagger_path = "/api-docs/openapi.json"
+      @swagger_root = "/api-docs"
+      @api_description = "An awsome API developed with MORTYMER"
+      @api_version = "v1"
+    end
+  end
+end

data/lib/mortymer/container.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "concurrent"
+
 module Mortymer
   # Base container for dependency injection
   class Container
@@ -8,115 +10,148 @@ module Mortymer
     class NotFoundError < Error; end
 
     class << self
+      # Get the global container instance
+      def instance
+        @instance ||= new
+      end
+
       # Initialize the container storage
       def registry
-        @registry ||= {}
+        instance.registry
       end
 
-      # Register a constant with its implementation
-      # @param constant [Class] The constant to register
-      # @param implementation [Object] The implementation to register
-      def register_constant(constant, implementation = nil, &block)
-        key = constant_to_key(constant)
-        registry[key] = block || implementation
+      # Create a new container with a copy of the current registry
+      def duplicate
+        new(registry.dup)
       end
 
-      # Resolve a constant to its implementation
-      # @param constant [Class] The constant to resolve
-      # @param resolution_stack [Array] Stack of constants being resolved to detect cycles
-      # @return [Object] The resolved implementation
-      def resolve_constant(constant, resolution_stack = []) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
-        key = constant_to_key(constant)
-
-        # Check for circular dependencies
-        if resolution_stack.include?(key)
-          raise DependencyError, "Circular dependency detected: #{resolution_stack.join(" -> ")} -> #{key}"
+      # Delegate instance methods to the singleton instance
+      def method_missing(method_name, *args, &block)
+        if instance.respond_to?(method_name)
+          instance.public_send(method_name, *args, &block)
+        else
+          super
         end
+      end
 
-        # Return cached instance if available
-        return registry[key] if registry[key] && !registry[key].is_a?(Class) && !registry[key].is_a?(Proc)
-
-        implementation = registry[key]
+      def respond_to_missing?(method_name, include_private = false)
+        instance.respond_to?(method_name, include_private) || super
+      end
+    end
 
-        # If not registered, try to resolve the constant from string/symbol
-        if !implementation && (constant.is_a?(String) || constant.is_a?(Symbol))
-          begin
-            const_name = constant.to_s
-            implementation = Object.const_get(const_name)
-            registry[key] = implementation
-          rescue NameError
-            raise NotFoundError, "No implementation found for #{key}"
-          end
-        end
+    attr_reader :registry
 
-        # If not registered, try to auto-resolve the constant if it's a class
-        if !implementation && constant.is_a?(Class)
-          implementation = constant
-          registry[key] = implementation
-        end
+    def initialize(initial_registry = Concurrent::Hash.new)
+      @registry = initial_registry
+    end
 
-        raise NotFoundError, "No implementation found for #{key}" unless implementation
+    def duplicate
+      self.class.new(registry.dup)
+    end
 
-        # Add current constant to resolution stack
-        resolution_stack.push(key)
+    # Register a constant with its implementation
+    # @param constant [Class] The constant to register
+    # @param implementation [Object] The implementation to register
+    def register_constant(constant, implementation = nil, &block)
+      key = constant_to_key(constant)
+      registry[key] = block || implementation
+    end
 
-        result = resolve_implementation(implementation, key, resolution_stack)
+    # Resolve a constant to its implementation
+    # @param constant [Class] The constant to resolve
+    # @param resolution_stack [Array] Stack of constants being resolved to detect cycles
+    # @return [Object] The resolved implementation
+    def resolve_constant(constant, resolution_stack = []) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+      key = constant_to_key(constant)
 
-        resolution_stack.pop
-        result
+      # Check for circular dependencies
+      if resolution_stack.include?(key)
+        raise DependencyError, "Circular dependency detected: #{resolution_stack.join(" -> ")} -> #{key}"
       end
 
-      private
-
-      # Resolve the actual implementation
-      def resolve_implementation(implementation, key, resolution_stack)
-        case implementation
-        when Proc
-          result = instance_exec(&implementation)
-          registry[key] = result
-          result
-        when Class
-          resolve_class(implementation, key, resolution_stack)
-        else
-          implementation
+      # Return cached instance if available
+      return registry[key] if registry[key] && !registry[key].is_a?(Class) && !registry[key].is_a?(Proc)
+
+      implementation = registry[key]
+
+      # If not registered, try to resolve the constant from string/symbol
+      if !implementation && (constant.is_a?(String) || constant.is_a?(Symbol))
+        begin
+          const_name = constant.to_s
+          implementation = Object.const_get(const_name)
+          registry[key] = implementation
+        rescue NameError
+          raise NotFoundError, "No implementation found for #{key}"
         end
       end
 
-      # Resolve a class implementation with its dependencies
-      def resolve_class(klass, key, resolution_stack)
-        instance = if klass.respond_to?(:dependencies)
-                     inject_dependencies(klass, resolution_stack)
-                   else
-                     klass.new
-                   end
-        registry[key] = instance
-        instance
+      # If not registered, try to auto-resolve the constant if it's a class
+      if !implementation && constant.is_a?(Class)
+        implementation = constant
+        registry[key] = implementation
       end
 
-      # Inject dependencies into a new instance
-      def inject_dependencies(klass, resolution_stack)
-        deps = klass.dependencies.map do |dep|
-          { var_name: dep[:var_name], value: resolve_constant(dep[:constant], resolution_stack.dup) }
-        end
+      raise NotFoundError, "No implementation found for #{key}" unless implementation
 
-        instance = klass.new
-        deps.each do |dep|
-          instance.instance_variable_set("@#{dep[:var_name]}", dep[:value])
-        end
-        instance
+      # Add current constant to resolution stack
+      resolution_stack.push(key)
+
+      result = resolve_implementation(implementation, key, resolution_stack)
+
+      resolution_stack.pop
+      result
+    end
+
+    private
+
+    # Resolve the actual implementation
+    def resolve_implementation(implementation, key, resolution_stack)
+      case implementation
+      when Proc
+        result = instance_exec(&implementation)
+        registry[key] = result
+        result
+      when Class
+        resolve_class(implementation, key, resolution_stack)
+      else
+        implementation
+      end
+    end
+
+    # Resolve a class implementation with its dependencies
+    def resolve_class(klass, key, resolution_stack)
+      instance = if klass.respond_to?(:dependencies)
+                   inject_dependencies(klass, resolution_stack)
+                 else
+                   klass.new
+                 end
+      registry[key] = instance
+      instance
+    end
+
+    # Inject dependencies into a new instance
+    def inject_dependencies(klass, resolution_stack)
+      deps = klass.dependencies.map do |dep|
+        { var_name: dep[:var_name], value: resolve_constant(dep[:constant], resolution_stack.dup) }
       end
 
-      # Convert a constant to a container registration key
-      # @param constant [Class] The constant to convert
-      # @return [String] The container registration key
-      def constant_to_key(constant)
-        key = if constant.is_a?(String) || constant.is_a?(Symbol)
-                constant.to_s
-              else
-                constant.name
-              end
-        Utils::StringTransformations.underscore(key.split("::").join("_"))
+      instance = klass.new
+      deps.each do |dep|
+        instance.instance_variable_set("@#{dep[:var_name]}", dep[:value])
       end
+      instance
+    end
+
+    # Convert a constant to a container registration key
+    # @param constant [Class] The constant to convert
+    # @return [String] The container registration key
+    def constant_to_key(constant)
+      key = if constant.is_a?(String) || constant.is_a?(Symbol)
+              constant.to_s
+            else
+              constant.name
+            end
+      Utils::StringTransformations.underscore(key.split("::").join("_"))
     end
   end
 end

data/lib/mortymer/dependencies_dsl.rb

@@ -47,12 +47,14 @@ module Mortymer
 
       # Inject all declared dependencies
       # @param overrides [Hash] Optional dependency overrides for named dependencies
-      def inject_dependencies(overrides = {})
+      # @param container [Mortymer::Container] Optional container to use for dependency resolution
+      def inject_dependencies(overrides = {}, container = nil)
+        container ||= Mortymer.config&.container || Container.new
         self.class.dependencies.each do |dep|
           value = if overrides.key?(dep[:var_name].to_sym)
                     overrides[dep[:var_name].to_sym]
                   else
-                    Container.resolve_constant(dep[:constant])
+                    container.resolve_constant(dep[:constant])
                   end
 
           instance_variable_set("@#{dep[:var_name]}", value)

data/lib/mortymer/dry_swagger.rb

@@ -1,6 +1,36 @@
 # frozen_string_literal: true
 
 require "dry_struct_parser/struct_schema_parser"
+
+# Need to monkey patch the nominal visitor for dry struct parser
+# as it currently does nothing with this field
+module DryStructParser
+  class StructSchemaParser
+    def visit_constructor(node, opts)
+      # Handle coercible types which have the form:
+      # [:constructor, [[:nominal, [Type, {}]], [:method, Kernel, :Type]]]
+      if node[0].is_a?(Array) && node[0][0] == :nominal
+        required = opts.fetch(:required, true)
+        nullable = opts.fetch(:nullable, false)
+        type = node[0][1][0] # Get the type from nominal node
+        if PREDICATE_TYPES[type.name.to_sym]
+          definition = {
+            type: PREDICATE_TYPES[type.name.to_sym],
+            required: required,
+            nullable: nullable
+          }
+          definition[:array] = opts[:array] if opts[:array]
+          keys[opts[:key]] = definition
+          return
+        end
+      end
+
+      # Fall back to regular visit for other cases
+      visit(node[0], opts)
+    end
+  end
+end
+
 require "dry_validation_parser/validation_schema_parser"
 require "dry/swagger/documentation_generator"
 require "dry/swagger/errors/missing_hash_schema_error"

data/lib/mortymer/endpoint.rb

@@ -93,7 +93,11 @@ module Mortymer
     def generate_parameters
       return [] unless @input_class && %i[get delete].include?(@http_method)
 
-      schema = Dry::Swagger::DocumentationGenerator.new.from_struct(@input_class)
+      schema = if @input_class.respond_to?(:json_schema)
+                 @input_class.json_schema
+               else
+                 Dry::Swagger::DocumentationGenerator.new.from_struct(@input_class)
+               end
       schema[:properties]&.map do |name, property|
         {
           name: name,

data/lib/mortymer/endpoint_registry.rb

@@ -5,11 +5,21 @@ module Mortymer
   class EndpointRegistry
     class << self
       def registry
-        @registry ||= []
+        if defined?(Rails.application) && Rails.application.config.cache_classes == false
+          Rails.application.reloader.wrap do
+            @registry ||= []
+          end
+        else
+          @registry ||= []
+        end
       end
 
       def get_matcher(path, method)
-        @registry.find { |e| e.path.to_s == path.to_s && e.http_method.to_s == method.to_s }
+        registry.find { |e| e.path.to_s == path.to_s && e.http_method.to_s == method.to_s }
+      end
+
+      def clear
+        @registry = nil
       end
     end
   end

data/lib/mortymer/rails/configuration.rb

@@ -4,12 +4,19 @@ module Mortymer
   module Rails
     # A configuration api for Rails & Morty integration
     class Configuration
-      attr_accessor :base_controller_class, :error_handler, :wrap_methods
+      attr_accessor :base_controller_class, :error_handler, :wrap_methods, :container, :api_title, :api_version,
+                    :api_description
 
       def initialize
         @base_controller_class = "ApplicationController"
         @error_handler = ->(error) { raise error }
         @wrap_methods = true
+        @container = Mortymer::Container.new
+
+        # API documentation defaults
+        @api_title = "Rick on Rails API"
+        @api_version = "v1"
+        @api_description = ""
       end
     end
   end

data/lib/mortymer/rails/routes.rb

@@ -10,13 +10,13 @@ module Mortymer
       end
 
       def mount_morty_endpoints
-        Morty::EndpointRegistry.registry.each do |endpoint|
+        Mortymer::EndpointRegistry.registry.each do |endpoint|
           mount_endpoint(endpoint)
         end
       end
 
       def mount_controllers
-        Morty::EndpointRegistry.registry.each do |endpoint|
+        Mortymer::EndpointRegistry.registry.each do |endpoint|
           mount_controller(endpoint)
         end
       end
@@ -40,21 +40,22 @@ module Mortymer
         path = endpoint.path || endpoint.infer_path_from_class
 
         # Store the endpoint class in the request env for the wrapper to access
-        defaults = { controller: "morty/rails/endpoint_wrapper", action: "handle" }
+        defaults = { controller: "mortymer/rails/endpoint_wrapper", action: "handle" }
         constraints = lambda do |request|
-          request.env["morty.endpoint_class"] = endpoint
+          request.env["mortymer.endpoint_class"] = endpoint
           true
         end
 
         case endpoint.http_method
         when :get
-          @drawer.get path, to: "morty/rails/endpoint_wrapper#handle", defaults: defaults, constraints: constraints
+          @drawer.get path, to: "mortymer/rails/endpoint_wrapper#handle", defaults: defaults, constraints: constraints
         when :post
-          @drawer.post path, to: "morty/rails/endpoint_wrapper#handle", defaults: defaults, constraints: constraints
+          @drawer.post path, to: "mortymer/rails/endpoint_wrapper#handle", defaults: defaults, constraints: constraints
         when :put
-          @drawer.put path, to: "morty/rails/endpoint_wrapper#handle", defaults: defaults, constraints: constraints
+          @drawer.put path, to: "mortymer/rails/endpoint_wrapper#handle", defaults: defaults, constraints: constraints
         when :delete
-          @drawer.delete path, to: "morty/rails/endpoint_wrapper#handle", defaults: defaults, constraints: constraints
+          @drawer.delete path, to: "mortymer/rails/endpoint_wrapper#handle", defaults: defaults,
+                               constraints: constraints
         end
       end
     end

data/lib/mortymer/railtie.rb

@@ -3,12 +3,39 @@
 require_relative "rails/routes"
 require_relative "rails/configuration"
 require_relative "rails/endpoint_wrapper_controller"
+require_relative "openapi_generator"
 
 module Mortymer
-  class Railtie < ::Rails::Railtie
+  class Railtie < ::Rails::Railtie # rubocop:disable Style/Documentation
     config.morty = Mortymer::Rails::Configuration.new
 
     initializer "mortymer.initialize" do |app|
+      # Clear registry on reload in development
+      if ::Rails.application.config.cache_classes == false
+        app.reloader.before_class_unload do
+          Mortymer::EndpointRegistry.clear
+        end
+
+        app.reloader.to_prepare do
+          # Routes will be remounted as classes are autoloaded
+          ::Rails.application.eager_load!
+
+          # Regenerate OpenAPI spec
+          generator = Mortymer::OpenapiGenerator.new(
+            registry: Mortymer::EndpointRegistry.registry,
+            title: Mortymer.config.swagger_title,
+            version: Mortymer.config.api_version,
+            description: Mortymer.config.api_description
+          )
+
+          # Save OpenAPI spec to public directory
+          spec_dir = ::Rails.root.join("api-docs")
+          FileUtils.mkdir_p(spec_dir)
+          File.write(spec_dir.join("openapi.json"), JSON.pretty_generate(generator.generate))
+
+          ::Rails.application.reload_routes!
+        end
+      end
     end
   end
 end

data/lib/mortymer/version.rb

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

data/lib/mortymer.rb

@@ -2,6 +2,7 @@
 # typed: true
 
 require "dry/struct"
+require "mortymer/configuration"
 require "mortymer/model"
 require "mortymer/endpoint"
 require "mortymer/dry_swagger"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mortymer
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - Adrian Gonzalez
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-03-06 00:00:00.000000000 Z
+date: 2025-03-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-monads
@@ -123,6 +123,7 @@ files:
 - docs/index.md
 - lib/mortymer.rb
 - lib/mortymer/api_metadata.rb
+- lib/mortymer/configuration.rb
 - lib/mortymer/container.rb
 - lib/mortymer/dependencies_dsl.rb
 - lib/mortymer/dry_swagger.rb