aris 1.3.0

data/lib/aris/response_helpers.rb

@@ -0,0 +1,156 @@
+# lib/aris/response_helpers.rb
+require 'json'
+
+module Aris
+  module ResponseHelpers
+    # JSON response
+    def json(data, status: 200)
+      self.status = status
+      self.headers['content-type'] = 'application/json'
+      self.body = [data.to_json]
+      self
+    end
+    
+    # HTML response
+    def html(content, status: 200)
+      self.status = status
+      self.headers['content-type'] = 'text/html; charset=utf-8'
+      self.body = [content.to_s]
+      self
+    end
+
+
+    def negotiate(format_preference, status: 200, &block)
+      format_to_use = case format_preference.to_s
+      when 'json', 'application/json' then :json
+      when 'xml', 'application/xml' then :xml
+      when 'html', 'text/html' then :html
+      else :json
+      end
+      
+      content = block.call(format_to_use) if block_given?
+      
+      case format_to_use
+      when :json
+        if content.is_a?(String) && content.start_with?('{', '[')
+          self.status = status
+          self.headers['content-type'] = 'application/json'
+          self.body = [content]
+        else
+          json(content || {}, status: status)
+        end
+      when :xml
+        xml(content || '', status: status)
+      when :html
+        html(content || '', status: status)
+      end
+      
+      self
+    end
+
+    # Plain text response
+    def text(content, status: 200)
+      self.status = status
+      self.headers['content-type'] = 'text/plain; charset=utf-8'
+      self.body = [content.to_s]
+      self
+    end
+    
+    # Redirect to URL
+    def redirect(url, status: 302)
+      self.status = status
+      self.headers['location'] = url
+      self.headers['content-type'] = 'text/plain; charset=utf-8'
+      self.body = ["Redirecting to #{url}"]
+      self
+    end
+    
+    # Redirect to named route
+    def redirect_to(route_name, status: 302, **params)
+      # Get domain from Thread context (set by adapter)
+      domain = Thread.current[:aris_current_domain]
+      path = Aris.path(domain, route_name, **params)
+      redirect(path, status: status)
+    end
+    
+    # No content response
+    def no_content
+      self.status = 204
+      self.headers.delete('content-type')
+      self.body = []
+      self
+    end
+    
+    # XML response
+    def xml(data, status: 200)
+      self.status = status
+      self.headers['content-type'] = 'application/xml; charset=utf-8'
+      self.body = [data.to_s]
+      self
+    end
+    
+    # Send file
+    def send_file(file_path, filename: nil, type: nil, disposition: 'attachment')
+      unless File.exist?(file_path)
+        raise ArgumentError, "File not found: #{file_path}"
+      end
+      
+      self.status = 200
+      
+      # Determine content type
+      content_type = type || detect_content_type(file_path)
+      self.headers['content-type'] = content_type
+      
+      # Set filename
+      download_filename = filename || File.basename(file_path)
+      self.headers['content-disposition'] = "#{disposition}; filename=\"#{download_filename}\""
+      
+      # Set content length
+      self.headers['content-length'] = File.size(file_path).to_s
+      
+      # Read file
+      self.body = [File.read(file_path)]
+      
+      self
+    end
+    
+    private
+    
+    def detect_content_type(file_path)
+      # Handle Tempfile paths that may have random extensions
+      ext = File.extname(file_path).downcase
+      ext = ext.split('.').last if ext.include?('.')
+      ext = ".#{ext}" unless ext.start_with?('.')
+      
+      MIME_TYPES[ext] || 'application/octet-stream'
+    end
+    
+    MIME_TYPES = {
+      '.html' => 'text/html',
+      '.htm' => 'text/html',
+      '.txt' => 'text/plain',
+      '.css' => 'text/css',
+      '.js' => 'application/javascript',
+      '.json' => 'application/json',
+      '.xml' => 'application/xml',
+      '.pdf' => 'application/pdf',
+      '.zip' => 'application/zip',
+      '.tar' => 'application/x-tar',
+      '.gz' => 'application/gzip',
+      '.jpg' => 'image/jpeg',
+      '.jpeg' => 'image/jpeg',
+      '.png' => 'image/png',
+      '.gif' => 'image/gif',
+      '.svg' => 'image/svg+xml',
+      '.webp' => 'image/webp',
+      '.ico' => 'image/x-icon',
+      '.mp3' => 'audio/mpeg',
+      '.mp4' => 'video/mp4',
+      '.webm' => 'video/webm',
+      '.woff' => 'font/woff',
+      '.woff2' => 'font/woff2',
+      '.ttf' => 'font/ttf',
+      '.otf' => 'font/otf'
+    }.freeze
+  end
+end

data/lib/aris/route_helpers.rb

@@ -0,0 +1,141 @@
+# lib/aris/route_helpers.rb
+module Aris
+  module RouteHelpers
+    # Declare localized paths (for file discovery)
+    # @example
+    #   localized es: 'acerca', en: 'about'
+    def localized(**paths)
+      @_localized_paths = paths
+    end
+    
+    def localized_paths
+      @_localized_paths || {}
+    end
+    
+    # Load localized data - SUPPORTS MULTIPLE FORMATS (.rb, .json, .yml)
+    # @param locale [Symbol] The locale to load data for (:es, :en, etc.)
+    # @return [Hash] The parsed data for the locale
+    # @raise [Aris::Router::LocaleError] If no data file found for locale
+    def load_localized_data(locale)
+      base_path = File.dirname(caller_locations.first.path)
+      
+      # Try multiple formats in priority order
+      [
+        ["data_#{locale}.rb", :ruby],
+        ["data_#{locale}.json", :json],
+        ["data_#{locale}.yml", :yaml],
+        ["data_#{locale}.yaml", :yaml],
+        ["data/#{locale}.json", :json],
+        ["data/#{locale}.yml", :yaml],
+        ["data/#{locale}.yaml", :yaml]
+      ].each do |filename, format|
+        file_path = File.join(base_path, filename)
+        next unless File.exist?(file_path)
+        
+        return case format
+        when :ruby
+          # Ruby file just returns a hash
+          eval(File.read(file_path), binding, file_path)
+        when :json
+          require 'json'
+          JSON.parse(File.read(file_path), symbolize_names: true)
+        when :yaml
+          require 'yaml'
+          # Ruby 2.6+ compatibility
+          if YAML.respond_to?(:load_file)
+            if RUBY_VERSION >= '2.6'
+              YAML.load_file(file_path, symbolize_names: true)
+            else
+              YAML.load_file(file_path)
+            end
+          else
+            YAML.load(File.read(file_path))
+          end
+        end
+      end
+      
+      raise Aris::Router::LocaleError, 
+        "No data file found for locale :#{locale} in #{base_path}"
+    end
+    
+    # Load template file from handler directory
+    # @param name [String] Template filename (default: 'template.html')
+    # @return [String] The template content
+    # @raise [Aris::Router::LocaleError] If template not found
+    def load_template(name = 'template.html')
+      file_path = File.join(
+        File.dirname(caller_locations.first.path),
+        name
+      )
+      
+      if File.exist?(file_path)
+        File.read(file_path)
+      else
+        raise Aris::Router::LocaleError, "Template not found: #{file_path}"
+      end
+    end
+    
+    # Render template with data using specified engine
+    # @param template_name [String] Name of template file
+    # @param data [Hash] Data to interpolate into template
+    # @param engine [Symbol] Template engine (:simple or :erb)
+    # @return [String] Rendered template
+    # @raise [Aris::Router::LocaleError] If template not found or engine unknown
+    #
+    # NOTE: This is a convenience helper. Handlers can use any template engine.
+    def render_template(template_name, data, engine: :simple)
+      template_path = File.join(
+        File.dirname(caller_locations.first.path),
+        template_name
+      )
+      template = File.read(template_path)
+      
+      case engine
+      when :erb
+        require 'erb'
+        # Ruby 2.6+ uses result_with_hash, earlier versions need binding
+        if ERB.instance_method(:result).parameters.any?
+          ERB.new(template).result(binding)
+        else
+          # For ERB that supports result_with_hash (Ruby 2.5+)
+          begin
+            ERB.new(template).result_with_hash(data)
+          rescue NoMethodError
+            # Fallback for older Ruby
+            ERB.new(template).result(binding)
+          end
+        end
+      when :simple
+        # Simple {{key}} interpolation for basic cases
+        template.gsub(/\{\{(\w+)\}\}/) { data[$1.to_sym] || data[$1.to_s] }
+      else
+        raise Aris::Router::LocaleError, "Unknown template engine: #{engine}"
+      end
+    rescue Errno::ENOENT
+      raise Aris::Router::LocaleError, "Template not found: #{template_path}"
+    end
+    
+    # Declare sitemap metadata (existing method)
+    def sitemap(priority: 0.5, changefreq: 'monthly', lastmod: nil, &dynamic)
+      @_sitemap_metadata = {
+        priority: priority,
+        changefreq: changefreq,
+        lastmod: lastmod,
+        dynamic: dynamic
+      }
+    end
+    
+    def sitemap_metadata
+      @_sitemap_metadata
+    end
+    
+    # Declare redirect sources (existing method)
+    def redirects_from(*paths, status: 301)
+      @_redirect_paths = { paths: paths, status: status }
+    end
+    
+    def redirect_metadata
+      @_redirect_paths
+    end
+  end
+end

data/lib/aris/utils/redirects.rb

@@ -0,0 +1,44 @@
+# lib/aris/utils/redirects.rb
+module Aris
+  module Utils
+    module Redirects
+      class << self
+        attr_reader :redirects
+        
+        def reset!
+          @redirects = {}
+        end
+        
+        def register(from_paths:, to_path:, status: 301)
+          @redirects ||= {}
+          Array(from_paths).each do |from_path|
+            @redirects[from_path] = { to: to_path, status: status }
+          end
+        end
+        
+        def find(path)
+          @redirects&.[](path)
+        end
+        
+        def all
+          @redirects || {}
+        end
+      end
+      
+      reset!
+    end
+  end
+end
+
+# Extend RouteHelpers
+module Aris
+	module RouteHelpers
+  def redirects_from(*paths, status: 301)
+    @_redirect_paths = { paths: paths, status: status }
+  end
+  
+  def redirect_metadata
+    @_redirect_paths
+  end
+  end
+end

data/lib/aris/utils/sitemap.rb

@@ -0,0 +1,84 @@
+# lib/aris/utils/sitemap.rb
+module Aris
+  module Utils
+    module Sitemap
+      class << self
+        attr_reader :routes
+        
+        def reset!
+          @routes = []
+        end
+        
+        def register(domain:, path:, method:, metadata:)
+          @routes ||= []
+          @routes << {
+            domain: domain,
+            path: path,
+            method: method,
+            metadata: metadata
+          }
+        end
+        
+        def generate(base_url:, domain: nil)
+          xml = ['<?xml version="1.0" encoding="UTF-8"?>']
+          xml << '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">'
+          
+          sitemap_routes(domain).each do |route|
+            route[:urls].each do |url_data|
+              xml << '  <url>'
+              xml << "    <loc>#{base_url}#{url_data[:path]}</loc>"
+              xml << "    <lastmod>#{url_data[:lastmod]}</lastmod>" if url_data[:lastmod]
+              xml << "    <changefreq>#{url_data[:changefreq]}</changefreq>"
+              xml << "    <priority>#{url_data[:priority]}</priority>"
+              xml << '  </url>'
+            end
+          end
+          
+          xml << '</urlset>'
+          xml.join("\n")
+        end
+        
+        private
+        
+        def sitemap_routes(domain_filter = nil)
+          (@routes || []).select { |r| 
+            r[:metadata] && (domain_filter.nil? || r[:domain] == domain_filter)
+          }.map { |route|
+            urls = if route[:metadata][:dynamic]
+              route[:metadata][:dynamic].call
+            else
+              [{
+                path: route[:path],
+                priority: route[:metadata][:priority] || 0.5,
+                changefreq: route[:metadata][:changefreq] || 'monthly',
+                lastmod: route[:metadata][:lastmod]
+              }]
+            end
+            
+            route.merge(urls: urls)
+          }.sort_by { |r| -(r[:urls].first[:priority] rescue 0.5) }
+        end
+      end
+      
+      reset!
+    end
+  end
+end
+
+# Extend RouteHelpers
+module Aris
+	module RouteHelpers
+  def sitemap(priority: 0.5, changefreq: 'monthly', lastmod: nil, &dynamic)
+    @_sitemap_metadata = {
+      priority: priority,
+      changefreq: changefreq,
+      lastmod: lastmod,
+      dynamic: dynamic
+    }
+  end
+  
+  def sitemap_metadata
+    @_sitemap_metadata
+  end
+  end
+end

data/lib/aris/version.rb

@@ -0,0 +1,3 @@
+module Aris
+  VERSION = "1.3.0"
+end

data/lib/aris.rb

@@ -0,0 +1,35 @@
+# lib/aris.rb
+# Main Aris loader - requires all components in correct order
+
+# Core functionality
+require_relative 'aris/version'
+require_relative 'aris/core'
+require_relative 'aris/pipeline_runner'
+require_relative 'aris/locale_injector'
+require_relative 'aris/route_helpers'
+require_relative 'aris/response_helpers'
+require_relative 'aris/discovery'
+require_relative 'aris/plugins'
+
+# Adapters
+require_relative 'aris/adapters/base'
+require_relative 'aris/adapters/joys_integration'
+require_relative 'aris/adapters/rack/response'
+require_relative 'aris/adapters/rack/request'
+require_relative 'aris/adapters/rack/adapter'
+require_relative 'aris/adapters/mock/response'
+require_relative 'aris/adapters/mock/request'
+require_relative 'aris/adapters/mock/adapter'
+
+# Utils (if available)
+begin
+  require_relative 'aris/utils/sitemap'
+  require_relative 'aris/utils/redirects'
+rescue LoadError
+  # Utils not available, that's ok
+end
+
+# Plugins (optional)
+Dir[File.join(__dir__, 'aris/plugins/**/*.rb')].sort.each do |file|
+  require file
+end

metadata

@@ -0,0 +1,151 @@
+--- !ruby/object:Gem::Specification
+name: aris
+version: !ruby/object:Gem::Version
+  version: 1.3.0
+platform: ruby
+authors:
+- Steven Garcia
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: benchmark-ips
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: benchmark-memory
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+description: Aris is a lightweight, high-performance web framework for Ruby with powerful
+  routing, middleware pipeline, and seamless integrations.
+email:
+- stevendgarcia@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/aris.rb
+- lib/aris/adapters/base.rb
+- lib/aris/adapters/joys_integration.rb
+- lib/aris/adapters/mock/adapter.rb
+- lib/aris/adapters/mock/request.rb
+- lib/aris/adapters/mock/response.rb
+- lib/aris/adapters/rack/adapter.rb
+- lib/aris/adapters/rack/request.rb
+- lib/aris/adapters/rack/response.rb
+- lib/aris/core.rb
+- lib/aris/discovery.rb
+- lib/aris/locale_injector.rb
+- lib/aris/pipeline_runner.rb
+- lib/aris/plugins.rb
+- lib/aris/plugins/api_key_auth.rb
+- lib/aris/plugins/basic_auth.rb
+- lib/aris/plugins/bearer_auth.rb
+- lib/aris/plugins/cache.rb
+- lib/aris/plugins/compression.rb
+- lib/aris/plugins/cookies.rb
+- lib/aris/plugins/cors.rb
+- lib/aris/plugins/csrf.rb
+- lib/aris/plugins/etag.rb
+- lib/aris/plugins/flash.rb
+- lib/aris/plugins/form_parser.rb
+- lib/aris/plugins/health_check.rb
+- lib/aris/plugins/json.rb
+- lib/aris/plugins/multipart.rb
+- lib/aris/plugins/rate_limiter.rb
+- lib/aris/plugins/request_id.rb
+- lib/aris/plugins/request_logger.rb
+- lib/aris/plugins/security_headers.rb
+- lib/aris/plugins/session.rb
+- lib/aris/response_helpers.rb
+- lib/aris/route_helpers.rb
+- lib/aris/utils/redirects.rb
+- lib/aris/utils/sitemap.rb
+- lib/aris/version.rb
+homepage: https://github.com/activestylus/aris
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Fast, elegant Ruby web framework
+test_files: []