aris 1.3.0 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 939f838547c98d96452cf200c2b5ae4d9cbdfaf17f6811415f2f341e7cf96a32
-  data.tar.gz: c7c25cd371a1413068d0b490b7d92fa29809c077fde4c04f75a8619427de600f
+  metadata.gz: bf323ca0ed960b60c26e09f0b575212544c8c5b15b95be5e299b6296f03d97df
+  data.tar.gz: a68dfcec5a685a815f069f960f9bdcf6462115d6f5758e4adbedaf3ddbe3b3fa
 SHA512:
-  metadata.gz: 4f4b0181b8df3cf3f7b421cbfef4bf9082324e833f31c688d638c41808845b81842448243da9e91279d0781f690edb7b76fde2c6859d060df58c4e3bf906e9fb
-  data.tar.gz: 756840ba2f35be79777e3aeeb01be6a4ca560119d85d5e5ba11a725cc7f87ab8e2afa73a0fbd22c5ac97f4dcccfde31bf1c1ff621cddeea62c4864c3df15bdc9
+  metadata.gz: d42298b4ba003ec4d10494b9545e23fc381e037087720293e176e46a49446d9897c665a8dc3d4e684551193df7b2c07850f8743542b75718b7242b0bda816246
+  data.tar.gz: b04ef54738e7f457ee594d83407f27a58b94b05c8d8c00c03106f9cfdaf950d3c58d0e153fdfe613d2e98f41a9216d10c93b84d9b9b5768e49474e9e40d283c2

data/lib/aris/adapters/base.rb

@@ -18,7 +18,7 @@ module Aris
         redirect = Aris::Utils::Redirects.find(request.path)
         return nil unless redirect
         
-        [redirect[:status], {'Location' => redirect[:to]}, []]
+        [redirect[:status], {'location' => redirect[:to]}, []]
       end
     end
   end

data/lib/aris/adapters/mock/adapter.rb

@@ -39,7 +39,7 @@ module Aris
             if domain_config && domain_config[:locales] && domain_config[:locales].any? && domain_config[:root_locale_redirect] != false
               if path == '/' || path.empty?
                 default_locale = domain_config[:default_locale] || domain_config[:locales].first
-                return { status: 302, headers: {'Location' => "/#{default_locale}/"}, body: [] }
+                return { status: 302, headers: {'location' => "/#{default_locale}/"}, body: [] }
               end
             end
             
@@ -52,7 +52,7 @@ module Aris
             if defined?(Aris::Utils::Redirects)
               redirect = Aris::Utils::Redirects.find(path)
               if redirect
-                return { status: redirect[:status], headers: {'Location' => redirect[:to]}, body: [] }
+                return { status: redirect[:status], headers: {'location' => redirect[:to]}, body: [] }
               end
             end
             
@@ -116,6 +116,24 @@ module Aris
           cookies
         end
 
+def handle_static(request)
+  return nil unless request.method == 'GET'
+  return nil unless Aris::Config.serve_static
+  
+  path = File.join('public', request.path)
+  return nil unless File.file?(path)
+  
+  [200, 
+    {'content-type' => mime_type(path)}, 
+    [File.binread(path)]
+  ]
+end
+
+def mime_type(path)
+  ext = File.extname(path).downcase
+  Aris::Config.mime_types[ext] || 'application/octet-stream'
+end
+
 def format_response(result, response = nil)
   case result
   when Response

data/lib/aris/adapters/rack/adapter.rb

@@ -13,57 +13,87 @@ module Aris
         @app = app
       end
 
-# lib/aris/adapters/rack/adapter.rb
-
-# lib/aris/adapters/rack/adapter.rb
+      def call(env)
+        request = Rack::Request.new(env)
+          static_response = handle_static(request)
+          return static_response if static_response
+          
+          sitemap_response = handle_sitemap(request)
+          return sitemap_response if sitemap_response
+          
+          redirect_response = handle_redirect(request)
+          return redirect_response if redirect_response
+          
+          redirect_res, normalized_path = Aris.handle_trailing_slash(request.path_info)
+          return redirect_res if redirect_res
+        
+        # return res if res = handle_static(request)
+        # return res if res = handle_sitemap(request)
+        # return res if res = handle_redirect(request)
+        # redirect_res, normalized_path = Aris.handle_trailing_slash(request.path_info)
+        # return redirect_res if redirect_res
+        
+        path_for_matching = normalized_path || request.path_info
+        
+        request_domain = request.host
+        Thread.current[:aris_current_domain] = request_domain
+        
+        response = Rack::Response.new
+        request.instance_variable_set(:@response, response)
+        request.define_singleton_method(:response) { @response }
 
-def call(env)
-  request = Rack::Request.new(env)
-  return res if res = handle_sitemap(request)
-  return res if res = handle_redirect(request)
-  redirect_res, normalized_path = Aris.handle_trailing_slash(request.path_info)
-  return redirect_res if redirect_res
-  
-  path_for_matching = normalized_path || request.path_info
-  
-  request_domain = request.host
-  Thread.current[:aris_current_domain] = request_domain
-  
-  response = Rack::Response.new
-  request.instance_variable_set(:@response, response)
-  request.define_singleton_method(:response) { @response }
-
-  begin
-    domain_config = Aris::Router.domain_config(request_domain)
-    route = Aris::Router.match(
-      domain: request_domain,
-      method: request.request_method.downcase.to_sym,
-      path: path_for_matching
-    )
-    if route
-      inject_locale_methods(request, route, domain_config)
-      result = PipelineRunner.call(request: request, route: route, response: response)
-      format_response(result, response)
-    else
-      format_response(Aris.not_found(request, response), response)
-    end
+        begin
+          domain_config = Aris::Router.domain_config(request_domain)
+          route = Aris::Router.match(
+            domain: request_domain,
+            method: request.request_method.downcase.to_sym,
+            path: path_for_matching
+          )
+          if route
+            inject_locale_methods(request, route, domain_config)
+            result = PipelineRunner.call(request: request, route: route, response: response)
+            format_response(result, response)
+          else
+            format_response(Aris.not_found(request, response), response)
+          end
 
-  rescue Aris::Router::RouteNotFoundError
-    format_response(Aris.not_found(request, response), response)
-  rescue Exception => e
-    # Error Path: 500
-    format_response(Aris.error(request, e), response)
+        rescue Aris::Router::RouteNotFoundError
+          format_response(Aris.not_found(request, response), response)
+        rescue Exception => e
+          # Error Path: 500
+          format_response(Aris.error(request, e), response)
 
-  ensure
-    Thread.current[:aris_current_domain] = nil
-  end
-end
+        ensure
+          Thread.current[:aris_current_domain] = nil
+        end
+      end
     
       def subdomain
         @subdomain || extract_subdomain_from_domain
       end
 
       private
+      def handle_static(request)
+        return nil unless request.request_method == 'GET'
+        return nil unless Aris::Config.serve_static
+        
+        path = File.join('public', request.path_info)
+        return nil unless File.file?(path)
+        
+        [200, 
+          {
+            'content-type' => mime_type(path),
+            'cache-control' => 'public, max-age=31536000'
+          }, 
+          [File.binread(path)]
+        ]
+      end
+
+      def mime_type(path)
+        ext = File.extname(path).downcase
+        Aris::Config.mime_types[ext] || 'application/octet-stream'
+      end
+
 
       def extract_subdomain_from_domain
         return nil unless @env[:subdomain] || @env['SUBDOMAIN']
@@ -72,46 +102,57 @@ end
       end
 
 
-def inject_locale_methods(request, route, domain_config)
-  return unless route[:locale]
+      def inject_locale_methods(request, route, domain_config)
+        return unless route[:locale]
+
+        # Inject the locale helper
+        request.define_singleton_method(:locale) { route[:locale] }
+        
+        # Inject domain-specific locale configuration if it exists
+        if domain_config
+          request.define_singleton_method(:available_locales) { domain_config[:locales] }
+          request.define_singleton_method(:default_locale) { domain_config[:default_locale] }
+        end
+      end
+      def handle_sitemap(request)
+        # Overridden by sitemap utils if loaded
+        nil
+      end
+
+      def handle_redirect(request)
+        # Overridden by redirects utils if loaded  
+        nil
+      end
+
+      def format_response(result, response = nil)
+        # 1. Identify the 'active' response source
+        # We check the passed object (response) and the returned object (result)
+        active_res = if result.respond_to?(:body) && !Array(result.body).empty?
+                       result
+                     elsif response.respond_to?(:body) && !Array(response.body).empty?
+                       response
+                     else
+                       nil
+                     end
+
+        # 2. If we found a response with content, send it to the Rack server
+        if active_res
+          # Standardize the body as an Array of Strings for Rack 3 compatibility
+          body = active_res.body
+          body = [body] if body.is_a?(String)
+          
+          return [active_res.status, active_res.headers, body]
+        end
+
+        # 3. Final Fallback (If Joys rendered nothing)
+        case result
+        when Array then result
+        when Hash  then [200, {'content-type' => 'application/json'}, [result.to_json]]
+        else            [200, {'content-type' => 'text/plain'}, [result.to_s]]
+        end
+      end
 
-  # Inject the locale helper
-  request.define_singleton_method(:locale) { route[:locale] }
-  
-  # Inject domain-specific locale configuration if it exists
-  if domain_config
-    request.define_singleton_method(:available_locales) { domain_config[:locales] }
-    request.define_singleton_method(:default_locale) { domain_config[:default_locale] }
-  end
-end
-
-def format_response(result, response = nil)
-  # 1. Identify the 'active' response source
-  # We check the passed object (response) and the returned object (result)
-  active_res = if result.respond_to?(:body) && !Array(result.body).empty?
-                 result
-               elsif response.respond_to?(:body) && !Array(response.body).empty?
-                 response
-               else
-                 nil
-               end
-
-  # 2. If we found a response with content, send it to the Rack server
-  if active_res
-    # Standardize the body as an Array of Strings for Rack 3 compatibility
-    body = active_res.body
-    body = [body] if body.is_a?(String)
-    
-    return [active_res.status, active_res.headers, body]
-  end
 
-  # 3. Final Fallback (If Joys rendered nothing)
-  case result
-  when Array then result
-  when Hash  then [200, {'content-type' => 'application/json'}, [result.to_json]]
-  else            [200, {'content-type' => 'text/plain'}, [result.to_s]]
-  end
-end
     end
   end
 end

data/lib/aris/config.rb

@@ -0,0 +1,53 @@
+module Aris
+  module Config
+    class << self
+      attr_accessor :trailing_slash, :trailing_slash_status,:secret_key_base, :cookie_options, :serve_static
+      DEFAULT_MIME_TYPES = {
+        '.html' => 'text/html',
+        '.css' => 'text/css',
+        '.js' => 'application/javascript',
+        '.json' => 'application/json',
+        '.jpg' => 'image/jpeg',
+        '.jpeg' => 'image/jpeg',
+        '.png' => 'image/png',
+        '.gif' => 'image/gif',
+        '.svg' => 'image/svg+xml',
+        '.webp' => 'image/webp',
+        '.ico' => 'image/x-icon',
+        '.woff' => 'font/woff',
+        '.woff2' => 'font/woff2',
+        '.ttf' => 'font/ttf',
+        '.pdf' => 'application/pdf',
+        '.xml' => 'application/xml',
+        '.txt' => 'text/plain',
+        '.mp3' => 'audio/mpeg',
+        '.wav' => 'audio/wav',
+        '.ogg' => 'audio/ogg',
+        '.flac' => 'audio/flac',
+        '.m4a' => 'audio/mp4'
+      }.freeze
+      def mime_types
+        @mime_types ||= DEFAULT_MIME_TYPES.dup
+      end
+      
+      def mime_types=(custom_types)
+        @mime_types = DEFAULT_MIME_TYPES.merge(custom_types)
+      end
+
+      def reset!
+        @trailing_slash = :strict
+        @serve_static = false
+        @trailing_slash_status = 301
+        @secret_key_base = nil
+        @cookie_options = {
+          httponly: true,
+          secure: false, # Default to false for development
+          same_site: :lax,
+          path: '/'
+        }
+      end
+    end
+    
+    reset!
+  end
+end