aris 1.3.0

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

@@ -0,0 +1,81 @@
+# lib/aris/adapters/mock/request.rb
+module Aris
+  module Adapters
+    module Mock
+      class Request
+        attr_reader :raw_request, :cookies  # Add cookies
+        attr_accessor :json_body
+        
+        def initialize(method:, path:, domain:, headers: {}, body: '', query: '', cookies: {})  # Add cookies parameter
+          @raw_request = {
+            method: method.to_s.upcase,
+            path: path,
+            domain: domain,
+            headers: headers,
+            body: body,
+            query: query
+          }
+          @cookies = cookies || {}  # Initialize cookies
+        end
+        
+        # Add env method for plugin compatibility
+        def env
+          @raw_request[:headers]
+        end
+        
+        def host
+          @raw_request[:domain]
+        end
+        
+        alias_method :domain, :host
+
+        def request_method
+          @raw_request[:method]
+        end
+        
+        def method
+          @raw_request[:method]
+        end
+
+        def path_info
+          @raw_request[:path]
+        end
+        
+        alias_method :path, :path_info
+
+        def query
+          @raw_request[:query]
+        end
+
+        def headers
+          @raw_request[:headers]
+        end
+
+        def body
+          @raw_request[:body]
+        end
+
+        def params
+          # Simple query string parser (no external dependencies)
+          return @params if @params
+          @params = {}
+          query.split('&').each do |pair|
+            key, value = pair.split('=')
+            @params[key] = value if key
+          end
+          @params
+        end
+        
+        def [](key)
+          case key
+          when :method then method
+          when :domain then domain
+          when :path then path
+          when :host then host
+          else @raw_request[key]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# lib/aris/adapters/mock/response.rb
+module Aris
+  module Adapters
+    module Mock
+      class Response
+        include Aris::ResponseHelpers
+        attr_accessor :status, :headers, :body
+
+        def initialize
+          @status = 200
+          @headers = {'content-type' => 'text/html'}
+          @body = []
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,117 @@
+# lib/aris/adapters/rack/adapter.rb
+require_relative '../../core'
+require_relative '../../pipeline_runner'
+require_relative '../base'
+require_relative 'request'
+require_relative 'response'
+require 'json'
+
+module Aris
+  module Adapters
+    class RackApp < Base 
+      def initialize(app = nil)
+        @app = app
+      end
+
+# lib/aris/adapters/rack/adapter.rb
+
+# lib/aris/adapters/rack/adapter.rb
+
+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
+
+  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
+    
+      def subdomain
+        @subdomain || extract_subdomain_from_domain
+      end
+
+      private
+
+      def extract_subdomain_from_domain
+        return nil unless @env[:subdomain] || @env['SUBDOMAIN']
+        
+        @env[:subdomain] || @env['SUBDOMAIN']
+      end
+
+
+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 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/adapters/rack/request.rb

@@ -0,0 +1,66 @@
+# lib/aris/adapters/rack/request.rb
+module Aris
+  module Adapters
+    module Rack
+      class Request
+        attr_reader :env
+        attr_accessor :json_body
+        
+        def initialize(env)
+          @env = env
+        end
+        
+        # Add cookies method to match Mock adapter interface
+        def cookies
+          @env['rack.request.cookie_hash'] || {}
+        end
+        
+        def host
+          @env['HTTP_HOST'] || @env['SERVER_NAME']
+        end
+        
+        alias_method :domain, :host
+
+        def request_method
+          @env['REQUEST_METHOD']
+        end
+        
+        def method
+          @env['REQUEST_METHOD']
+        end
+
+        def path_info
+          @env['PATH_INFO']
+        end
+        
+        alias_method :path, :path_info
+
+        def query
+          @env['QUERY_STRING']
+        end
+
+        def headers
+          @env.select { |k, v| k.start_with?('HTTP_') }
+        end
+
+        def body
+          @env['rack.input']&.read
+        end
+
+        def params
+          @params ||= ::Rack::Utils.parse_nested_query(@env['QUERY_STRING'] || '')
+        end
+        
+        def [](key)
+          case key
+          when :method then method
+          when :domain then domain
+          when :path then path
+          when :host then host
+          else @env[key.to_s]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# lib/aris/adapters/rack/response.rb
+module Aris
+  module Adapters
+    module Rack
+      class Response
+        include Aris::ResponseHelpers
+        attr_accessor :status, :headers, :body
+        def initialize
+          @status = 200
+          @headers = {'content-type' => 'text/html'}
+          @body = []
+        end
+      end
+    end
+  end
+end