rapitapir 0.1.1 → 2.0.0

data/lib/rapitapir/sinatra/oauth2_helpers.rb

@@ -10,37 +10,37 @@ module RapiTapir
       # Configure Auth0 OAuth2 authentication
       def auth0_oauth2(scheme_name = :oauth2_auth0, domain:, audience:, **options)
         auth_scheme = RapiTapir::Auth::OAuth2::Auth0Scheme.new(scheme_name, {
-          domain: domain,
-          audience: audience,
-          **options
-        })
-        
+                                                                 domain: domain,
+                                                                 audience: audience,
+                                                                 **options
+                                                               })
+
         # Store the auth scheme for use in endpoint protection
         settings.rapitapir_config.add_auth_scheme(scheme_name, auth_scheme)
-        
+
         # Add authentication helper methods
         helpers do
           include OAuth2HelperMethods
         end
-        
+
         auth_scheme
       end
 
       # Configure generic OAuth2 authentication with token introspection
       def oauth2_introspection(scheme_name = :oauth2, introspection_endpoint:, client_id:, client_secret:, **options)
         auth_scheme = RapiTapir::Auth::OAuth2::GenericScheme.new(scheme_name, {
-          introspection_endpoint: introspection_endpoint,
-          client_id: client_id,
-          client_secret: client_secret,
-          **options
-        })
-        
+                                                                   introspection_endpoint: introspection_endpoint,
+                                                                   client_id: client_id,
+                                                                   client_secret: client_secret,
+                                                                   **options
+                                                                 })
+
         settings.rapitapir_config.add_auth_scheme(scheme_name, auth_scheme)
-        
+
         helpers do
           include OAuth2HelperMethods
         end
-        
+
         auth_scheme
       end
 
@@ -58,7 +58,7 @@ module RapiTapir
         before do
           # Skip protection for excluded paths
           next if except.any? { |pattern| request.path_info.match?(pattern) }
-          
+
           authorize_oauth2!(required_scopes: scopes, scheme: scheme)
         end
       end
@@ -69,20 +69,18 @@ module RapiTapir
       # Authenticate and authorize with OAuth2
       def authorize_oauth2!(required_scopes: [], scheme: :oauth2_auth0)
         auth_scheme = settings.rapitapir_config.auth_schemes[scheme]
-        
-        unless auth_scheme
-          halt 500, { error: 'OAuth2 authentication not configured' }.to_json
-        end
+
+        halt 500, { error: 'OAuth2 authentication not configured' }.to_json unless auth_scheme
 
         begin
           context = auth_scheme.authenticate(request)
-          
+
           unless context
             challenge = auth_scheme.challenge
             headers 'WWW-Authenticate' => challenge
-            halt 401, { 
+            halt 401, {
               error: 'unauthorized',
-              error_description: 'Access token required' 
+              error_description: 'Access token required'
             }.to_json
           end
 
@@ -92,7 +90,7 @@ module RapiTapir
           # Check required scopes if specified
           if required_scopes.any?
             missing_scopes = required_scopes - context.scopes
-            
+
             if missing_scopes.any?
               halt 403, {
                 error: 'insufficient_scope',
@@ -135,34 +133,34 @@ module RapiTapir
       # Check if user has specific scope
       def has_scope?(scope)
         return false unless current_auth_context
-        
+
         current_auth_context.scopes.include?(scope.to_s)
       end
 
       # Check if user has all required scopes
       def has_scopes?(*scopes)
         return false unless current_auth_context
-        
+
         scopes.all? { |scope| has_scope?(scope) }
       end
 
       # Check if user has any of the specified scopes
       def has_any_scope?(*scopes)
         return false unless current_auth_context
-        
+
         scopes.any? { |scope| has_scope?(scope) }
       end
 
       # Require specific scopes for the current request
       def require_scopes!(*scopes)
         missing_scopes = scopes.reject { |scope| has_scope?(scope) }
-        
-        if missing_scopes.any?
-          halt 403, {
-            error: 'insufficient_scope',
-            error_description: "Missing required scopes: #{missing_scopes.join(', ')}"
-          }.to_json
-        end
+
+        return unless missing_scopes.any?
+
+        halt 403, {
+          error: 'insufficient_scope',
+          error_description: "Missing required scopes: #{missing_scopes.join(', ')}"
+        }.to_json
       end
 
       # Extract token from Authorization header
@@ -226,11 +224,7 @@ module RapiTapir
 end
 
 # Extend the Sinatra extension with OAuth2 helpers if it exists
-if defined?(RapiTapir::Sinatra::Extension)
-  RapiTapir::Sinatra::Extension::ClassMethods.include(RapiTapir::Sinatra::OAuth2Helpers)
-end
+RapiTapir::Sinatra::Extension::ClassMethods.include(RapiTapir::Sinatra::OAuth2Helpers) if defined?(RapiTapir::Sinatra::Extension)
 
 # Extend endpoint building with OAuth2 methods
-if defined?(RapiTapir::DSL::FluentEndpointBuilder)
-  RapiTapir::DSL::FluentEndpointBuilder.include(RapiTapir::Sinatra::OAuth2EndpointExtensions)
-end
+RapiTapir::DSL::FluentEndpointBuilder.include(RapiTapir::Sinatra::OAuth2EndpointExtensions) if defined?(RapiTapir::DSL::FluentEndpointBuilder)

data/lib/rapitapir/types/array.rb

@@ -136,12 +136,16 @@ module RapiTapir
         schema[:uniqueItems] = constraints[:unique_items] if constraints[:unique_items]
       end
 
+      public
+
       def to_s
         item_type_str = format_item_type_string
         constraint_part = format_constraints_string
         "Array[#{item_type_str}]#{constraint_part}"
       end
 
+      private
+
       def format_item_type_string
         item_type.respond_to?(:to_s) ? item_type.to_s : item_type.class.name
       end

data/lib/rapitapir/types/auto_derivation.rb

@@ -22,7 +22,6 @@ module RapiTapir
         # @param only [Array<Symbol>] Only include these fields
         # @param except [Array<Symbol>] Exclude these fields
         # @return [RapiTapir::Types::Hash]
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def from_hash(hash, only: nil, except: nil)
           raise ArgumentError, "Expected Hash, got #{hash.class}" unless hash.is_a?(::Hash)
 
@@ -39,7 +38,6 @@ module RapiTapir
 
           create_hash_type(schema_hash)
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         # Derive schema from JSON Schema object
         #
@@ -47,11 +45,8 @@ module RapiTapir
         # @param only [Array<Symbol>] Only include these fields
         # @param except [Array<Symbol>] Exclude these fields
         # @return [RapiTapir::Types::Hash]
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def from_json_schema(json_schema, only: nil, except: nil)
-          unless json_schema.is_a?(::Hash) && json_schema['type'] == 'object'
-            raise ArgumentError, 'JSON Schema must be an object type'
-          end
+          raise ArgumentError, 'JSON Schema must be an object type' unless json_schema.is_a?(::Hash) && json_schema['type'] == 'object'
 
           properties = json_schema['properties'] || {}
           required_fields = Array(json_schema['required'])
@@ -69,7 +64,6 @@ module RapiTapir
 
           RapiTapir::Types.hash(schema_hash)
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         # Derive schema from OpenStruct instance
         #
@@ -77,7 +71,7 @@ module RapiTapir
         # @param only [Array<Symbol>] Only include these fields
         # @param except [Array<Symbol>] Exclude these fields
         # @return [RapiTapir::Types::Hash]
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Style/OpenStructUse
+        # rubocop:disable Style/OpenStructUse
         def from_open_struct(open_struct, only: nil, except: nil)
           raise ArgumentError, "Expected OpenStruct, got #{open_struct.class}" unless open_struct.is_a?(OpenStruct)
 
@@ -93,7 +87,7 @@ module RapiTapir
 
           create_hash_type(schema_hash)
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Style/OpenStructUse
+        # rubocop:enable Style/OpenStructUse
 
         # Derive schema from Protobuf message class
         #
@@ -101,11 +95,8 @@ module RapiTapir
         # @param only [Array<Symbol>] Only include these fields
         # @param except [Array<Symbol>] Exclude these fields
         # @return [RapiTapir::Types::Hash]
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def from_protobuf(proto_class, only: nil, except: nil)
-          unless defined?(Google::Protobuf) && proto_class.respond_to?(:descriptor)
-            raise ArgumentError, 'Protobuf not available or invalid protobuf class'
-          end
+          raise ArgumentError, 'Protobuf not available or invalid protobuf class' unless defined?(Google::Protobuf) && proto_class.respond_to?(:descriptor)
 
           schema_hash = {}
           proto_class.descriptor.each do |field_descriptor|
@@ -121,12 +112,10 @@ module RapiTapir
 
           create_hash_type(schema_hash)
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         private
 
         # Convert JSON Schema field type to RapiTapir type
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
         def convert_json_schema_type(field_schema, required: true)
           base_type = case field_schema['type']
                       when 'string'
@@ -163,7 +152,6 @@ module RapiTapir
 
           required ? base_type : create_optional_type(base_type)
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
 
         # Convert protobuf field descriptor to RapiTapir type
         def convert_protobuf_type(field_descriptor)
@@ -189,7 +177,6 @@ module RapiTapir
         end
 
         # Infer RapiTapir type from Ruby value
-        # rubocop:disable Metrics/CyclomaticComplexity
         def infer_type_from_value(value)
           case value
           when ::Integer
@@ -212,7 +199,6 @@ module RapiTapir
             create_string_type
           end
         end
-        # rubocop:enable Metrics/CyclomaticComplexity
 
         # Helper methods to create types without using convenience methods
         def create_string_type

data/lib/rapitapir/types/datetime.rb

@@ -42,9 +42,7 @@ module RapiTapir
           # Assume Unix timestamp
           ::Time.at(value).to_datetime
         else
-          unless value.respond_to?(:to_datetime)
-            raise CoercionError.new(value, 'DateTime', 'Value cannot be converted to DateTime')
-          end
+          raise CoercionError.new(value, 'DateTime', 'Value cannot be converted to DateTime') unless value.respond_to?(:to_datetime)
 
           value.to_datetime
 

data/lib/rapitapir/types/float.rb

@@ -39,9 +39,7 @@ module RapiTapir
       def validate_minimum_constraints(float_value)
         errors = []
 
-        if constraints[:minimum] && float_value < constraints[:minimum]
-          errors << "Value #{float_value} is below minimum #{constraints[:minimum]}"
-        end
+        errors << "Value #{float_value} is below minimum #{constraints[:minimum]}" if constraints[:minimum] && float_value < constraints[:minimum]
 
         if constraints[:exclusive_minimum] && float_value <= constraints[:exclusive_minimum]
           errors << "Value #{float_value} must be greater than #{constraints[:exclusive_minimum]}"
@@ -53,9 +51,7 @@ module RapiTapir
       def validate_maximum_constraints(float_value)
         errors = []
 
-        if constraints[:maximum] && float_value > constraints[:maximum]
-          errors << "Value #{float_value} exceeds maximum #{constraints[:maximum]}"
-        end
+        errors << "Value #{float_value} exceeds maximum #{constraints[:maximum]}" if constraints[:maximum] && float_value > constraints[:maximum]
 
         if constraints[:exclusive_maximum] && float_value >= constraints[:exclusive_maximum]
           errors << "Value #{float_value} must be less than #{constraints[:exclusive_maximum]}"

data/lib/rapitapir/types/hash.rb

@@ -9,7 +9,7 @@ module RapiTapir
     class Hash < Base
       attr_reader :field_types
 
-      def initialize(field_types = {}, additional_properties: true, **options)
+      def initialize(field_types = {}, additional_properties: false, **options)
         @field_types = field_types.freeze
         super(
           additional_properties: additional_properties,
@@ -39,6 +39,16 @@ module RapiTapir
 
         field_types.each do |field_name, field_type|
           field_value = extract_field_value(value, field_name)
+
+          # Check for missing required fields
+          if field_value.nil? && !field_type.optional?
+            errors << "Required field '#{field_name}' is missing"
+            next
+          end
+
+          # Skip validation for optional missing fields
+          next if field_value.nil? && field_type.optional?
+
           field_result = field_type.validate(field_value)
           next if field_result[:valid]
 
@@ -82,6 +92,9 @@ module RapiTapir
       def coerce_hash_value(value)
         coerced = {}
 
+        # Check for unexpected fields if additional properties are not allowed
+        validate_no_unexpected_fields(value) unless constraints[:additional_properties]
+
         # Coerce defined fields
         coerce_defined_fields(value, coerced)
 
@@ -91,10 +104,33 @@ module RapiTapir
         coerced
       end
 
+      def validate_no_unexpected_fields(value)
+        expected_keys = field_types.keys.map { |k| [k, k.to_s, k.to_sym] }.flatten.uniq
+        unexpected_keys = value.keys - expected_keys
+        return if unexpected_keys.empty?
+
+        unexpected_list = unexpected_keys.map(&:inspect).join(', ')
+        raise CoercionError.new(value, 'Hash', "Unexpected fields in hash: #{unexpected_list}. Only these fields are allowed: #{field_types.keys.join(', ')}")
+      end
+
       def coerce_defined_fields(value, coerced)
         field_types.each do |field_name, field_type|
           field_value = find_field_value(value, field_name)
-          coerced[field_name] = field_type.coerce(field_value) if field_value || !field_type.optional?
+
+          # Check for missing required fields
+          if field_value.nil? && !field_type.optional?
+            raise CoercionError.new(nil, field_type.class.name, "Required field '#{field_name}' is missing from hash")
+          end
+
+          # Only coerce if we have a value or field is optional
+          next unless field_value || !field_type.optional?
+
+          begin
+            coerced[field_name] = field_type.coerce(field_value)
+          rescue CoercionError => e
+            # Re-raise with field context
+            raise CoercionError.new(e.value, e.type, "Field '#{field_name}': #{e.reason}")
+          end
         end
       end
 
@@ -148,6 +184,8 @@ module RapiTapir
         schema[:additionalProperties] = constraints[:additional_properties]
       end
 
+      public
+
       def to_s
         if field_types.empty?
           'Hash'

data/lib/rapitapir/types/integer.rb

@@ -46,9 +46,7 @@ module RapiTapir
       def validate_minimum_constraints(value)
         errors = []
 
-        if constraints[:minimum] && value < constraints[:minimum]
-          errors << "Value #{value} is below minimum #{constraints[:minimum]}"
-        end
+        errors << "Value #{value} is below minimum #{constraints[:minimum]}" if constraints[:minimum] && value < constraints[:minimum]
 
         if constraints[:exclusive_minimum] && value <= constraints[:exclusive_minimum]
           errors << "Value #{value} must be greater than #{constraints[:exclusive_minimum]}"
@@ -60,9 +58,7 @@ module RapiTapir
       def validate_maximum_constraints(value)
         errors = []
 
-        if constraints[:maximum] && value > constraints[:maximum]
-          errors << "Value #{value} exceeds maximum #{constraints[:maximum]}"
-        end
+        errors << "Value #{value} exceeds maximum #{constraints[:maximum]}" if constraints[:maximum] && value > constraints[:maximum]
 
         if constraints[:exclusive_maximum] && value >= constraints[:exclusive_maximum]
           errors << "Value #{value} must be less than #{constraints[:exclusive_maximum]}"
@@ -74,9 +70,7 @@ module RapiTapir
       def validate_multiple_constraint(value)
         errors = []
 
-        if constraints[:multiple_of] && (value % constraints[:multiple_of]) != 0
-          errors << "Value #{value} is not a multiple of #{constraints[:multiple_of]}"
-        end
+        errors << "Value #{value} is not a multiple of #{constraints[:multiple_of]}" if constraints[:multiple_of] && (value % constraints[:multiple_of]) != 0
 
         errors
       end
@@ -103,9 +97,7 @@ module RapiTapir
       end
 
       def coerce_other_to_integer(value)
-        unless value.respond_to?(:to_i)
-          raise CoercionError.new(value, 'Integer', 'Value cannot be converted to integer')
-        end
+        raise CoercionError.new(value, 'Integer', 'Value cannot be converted to integer') unless value.respond_to?(:to_i)
 
         value.to_i
       end

data/lib/rapitapir/types/object.rb

@@ -9,14 +9,14 @@ module RapiTapir
     class Object < Base
       attr_reader :fields
 
-      def initialize(**options, &block)
+      def initialize(**options, &)
         @fields = {}
         super(**options)
 
         return unless block_given?
 
         builder = ObjectBuilder.new(self)
-        builder.instance_eval(&block)
+        builder.instance_eval(&)
       end
 
       def field(name, type, required: true, **options)
@@ -118,6 +118,8 @@ module RapiTapir
         schema[:additionalProperties] = false # Objects are strict by default
       end
 
+      public
+
       def to_s
         if fields.empty?
           'Object'
@@ -127,6 +129,8 @@ module RapiTapir
         end
       end
 
+      private
+
       def extract_field_value(hash, field_name)
         # Try different key formats: symbol, string, and string version of symbol
         hash[field_name] || hash[field_name.to_s] || hash[field_name.to_sym]

data/lib/rapitapir/types.rb

@@ -124,12 +124,16 @@ module RapiTapir
       Hash.new(field_types, **options)
     end
 
+    def self.open_hash(field_types = {}, **options)
+      Hash.new(field_types, additional_properties: true, **options)
+    end
+
     def self.optional(type)
       Optional.new(type)
     end
 
-    def self.object(&block)
-      Object.new(&block)
+    def self.object(&)
+      Object.new(&)
     end
 
     # Auto-derivation convenience methods

data/lib/rapitapir/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RapiTapir
-  VERSION = '0.1.1'
+  VERSION = '2.0.0'
 end

data/lib/rapitapir.rb

@@ -43,10 +43,12 @@ rescue LoadError
   # Sinatra not available
 end
 
+# Rails integration (load unconditionally since Rails apps will define Rails)
 begin
-  require_relative 'rapitapir/server/rails_adapter' if defined?(Rails)
-rescue LoadError
-  # Rails not available
+  require_relative 'rapitapir/server/rails_integration'
+rescue LoadError => e
+  # Rails integration files not available
+  warn "Rails integration not available: #{e.message}" if $DEBUG
 end
 
 # OpenAPI and client generation (optional)

data/rapitapir.gemspec

@@ -41,16 +41,18 @@ Gem::Specification.new do |spec|
 
   # Runtime dependencies
   spec.add_dependency 'json', '~> 2.0'
-  spec.add_dependency 'rack', '~> 2.0', '>= 2.0'
+  spec.add_dependency 'rack', '>= 2.0', '< 4.0'
+  spec.add_dependency 'webrick', '~> 1.7'
 
   # Optional framework dependencies
-  spec.add_dependency 'sinatra', '>= 2.0', '< 4.0'
+  spec.add_dependency 'sinatra', '>= 2.0', '< 5.0'
 
   # Development dependencies
-  spec.add_development_dependency 'rack-test', '~> 2.0'
-  spec.add_development_dependency 'rspec', '~> 3.12'
+  spec.add_development_dependency 'puma', '~> 6.0'
+  spec.add_development_dependency 'rack-test', '~> 2.1'
+  spec.add_development_dependency 'rspec', '~> 3.13'
   spec.add_development_dependency 'simplecov', '~> 0.22'
-  spec.add_development_dependency 'webrick', '~> 1.8'
+  spec.add_development_dependency 'webmock', '~> 3.19'
 
   # Documentation
   spec.add_development_dependency 'redcarpet', '~> 3.6'