hyraft 0.1.0.alpha1

data/lib/hyraft/boot/preloader.rb

@@ -0,0 +1,206 @@
+# framework/boot/preloader.rb - Complete fixed version
+module Hyraft
+  module Preloader
+    COLORS = {
+      green:  "\e[32m",
+      cyan:   "\e[36m", 
+      yellow: "\e[33m",
+      red:    "\e[31m",
+      orange: "\e[38;5;214m",  
+      blue:   "\e[34m",     
+      lightblue: "\e[94m",   
+      reset:  "\e[0m"
+    }
+
+    @preloaded_templates = {}
+    @layout_content = nil
+    @stats = { 
+      total_templates: 0, 
+      total_bytes: 0,
+      compiled_bytes: 0,
+      load_time: 0.0
+    }
+
+    def self.preload_templates
+      puts "#{COLORS[:green]} Hyraft Preloader: Scanning for templates...#{COLORS[:reset]}"
+      
+      start_time = Time.now
+      
+      # Load layout first
+      layout_file = File.join(ROOT, 'public', 'index.html')
+      @layout_content = File.read(layout_file) if File.exist?(layout_file)
+      
+      templates_found = discover_templates
+      puts "Found #{templates_found.size} template files"
+      
+      templates_found.each do |file_path|
+        preload_template(file_path)
+      end
+      
+      @stats[:load_time] = Time.now - start_time
+      print_stats
+    end
+
+    def self.discover_templates
+      Dir.glob(File.join('adapter-intake', '**', '*.hyr')).sort
+    end
+
+    def self.preload_template(file_path)
+      template_key = file_path
+        .delete_prefix('adapter-intake/')
+        .sub(/\.hyr$/, '')
+      
+      begin
+        content = File.read(file_path)
+        sections = extract_sections(content)
+        
+        # ONLY pre-compile templates WITHOUT transmuter code (pure HTML templates)
+        compiled_html = nil
+        compile_success = false
+        compile_error = nil
+        
+        if @layout_content && sections[:transmuter].to_s.strip.empty?
+          begin
+            # Only compile templates that don't have Ruby code in transmuter
+            renderer = Hyraft::Compiler::HyraftRenderer.new
+            
+            # For pure HTML templates, we can safely compile with empty locals
+            # The [.variable.] placeholders will remain as-is for runtime replacement
+            compiled_html = renderer.render(@layout_content.dup, sections, {})
+            compile_success = true
+            
+          rescue => e
+            compile_error = e.message
+          end
+        else
+          compile_error = "has transmuter code" if sections[:transmuter] && !sections[:transmuter].empty?
+        end
+        
+        @preloaded_templates[template_key] = {
+          sections: sections,
+          compiled_html: compiled_html,
+          compile_success: compile_success,
+          compile_error: compile_error,
+          bytesize: content.bytesize,
+          compiled_bytes: compiled_html&.bytesize || 0,
+          mtime: File.mtime(file_path),
+          full_path: file_path
+        }
+        
+        @stats[:total_templates] += 1
+        @stats[:total_bytes] += content.bytesize
+        @stats[:compiled_bytes] += compiled_html&.bytesize || 0
+        
+        if compile_success
+          puts "  #{COLORS[:green]}✓#{COLORS[:reset]} #{COLORS[:lightblue]}#{template_key}#{COLORS[:reset]}#{COLORS[:orange]}.hyr#{COLORS[:reset]} (#{COLORS[:yellow]}#{(compiled_html.bytesize / 1024.0).round(2)} KB#{COLORS[:reset]})"
+        elsif compile_error == "has transmuter code"
+          puts "  #{COLORS[:blue]}ℹ#{COLORS[:reset]} #{COLORS[:lightblue]}#{template_key}#{COLORS[:reset]}#{COLORS[:orange]}.hyr#{COLORS[:reset]} (#{COLORS[:cyan]}dynamic template#{COLORS[:reset]})"
+        else
+          puts "  #{COLORS[:yellow]}⚠#{COLORS[:reset]} #{COLORS[:lightblue]}#{template_key}#{COLORS[:reset]}#{COLORS[:orange]}.hyr#{COLORS[:reset]} (#{COLORS[:red]}sections only#{COLORS[:reset]})"
+        end
+             
+      rescue => e
+        puts "  #{COLORS[:red]}✗#{COLORS[:reset]} #{COLORS[:cyan]}#{template_key}#{COLORS[:reset]}#{COLORS[:green]}.hyr#{COLORS[:reset]} #{COLORS[:red]}Error: #{e.message}#{COLORS[:reset]}"
+      end
+    end
+
+    def self.get_template(template_key)
+      @preloaded_templates[template_key]
+    end
+
+    def self.template_preloaded?(template_key)
+      @preloaded_templates.key?(template_key)
+    end
+
+    def self.render_template(template_key, locals = {})
+      return "<h1>Template not found: #{template_key}</h1>" unless template_preloaded?(template_key)
+      
+      template_data = get_template(template_key)
+      
+      # ULTRA FAST PATH: Use pre-compiled HTML (only for templates without transmuter)
+      if template_data[:compiled_html] && template_data[:compile_success]
+        return apply_locals_to_compiled(template_data[:compiled_html].dup, locals)
+      end
+      
+      # FAST PATH: Use preloaded sections with HyraftRenderer (for dynamic templates)
+      layout_file = File.join(ROOT, 'public', 'index.html')
+      layout_content = File.read(layout_file) if File.exist?(layout_file)
+      
+      renderer = Hyraft::Compiler::HyraftRenderer.new
+      renderer.render(layout_content, template_data[:sections], locals)
+    end
+
+    # FAST: Apply locals to pre-compiled HTML (only for placeholders, no Ruby execution)
+    def self.apply_locals_to_compiled(compiled_html, locals)
+      return compiled_html if locals.empty?
+      
+      # Simple string replacement for [.variable.] placeholders
+      locals.each do |key, value|
+        placeholder = "[.#{key}.]"
+        compiled_html = compiled_html.gsub(placeholder, value.to_s)
+      end
+      compiled_html
+    end
+
+    def self.stats
+      @stats.dup
+    end
+
+    private
+
+    def self.extract_sections(content)
+      {
+        metadata: extract_section(content, 'metadata'),
+        displayer: extract_section(content, 'displayer'), 
+        transmuter: extract_section(content, 'transmuter'),
+        manifestor: extract_section(content, 'manifestor'),
+        styles: extract_styles(content)
+      }
+    end
+
+    def self.extract_section(content, section_name)
+      match = content.match(/<#{section_name}.*?>(.*?)<\/#{section_name}>/m)
+      match ? match[1].strip : ''
+    end
+
+    def self.extract_styles(content)
+      content.scan(/<style[^>]*href="([^"]*)"/).flatten
+    end
+
+    def self.print_stats
+      compiled_count = @preloaded_templates.count { |_, t| t[:compile_success] }
+      dynamic_count = @preloaded_templates.count { |_, t| t[:compile_error] == "has transmuter code" }
+      sections_count = @preloaded_templates.count - compiled_count - dynamic_count
+      
+      puts "\n#{COLORS[:green]}Preload Statistics:#{COLORS[:reset]}"
+      puts "   #{COLORS[:cyan]}Templates:#{COLORS[:reset]} #{@stats[:total_templates]} (#{compiled_count} pre-compiled, #{dynamic_count} dynamic, #{sections_count} sections only)"
+      puts "   #{COLORS[:cyan]}Source Size:#{COLORS[:reset]} #{(@stats[:total_bytes] / 1024.0).round(2)} KB" 
+      puts "   #{COLORS[:cyan]}Compiled Size:#{COLORS[:reset]} #{(@stats[:compiled_bytes] / 1024.0).round(2)} KB" 
+      puts "   #{COLORS[:cyan]}Load Time:#{COLORS[:reset]} #{@stats[:load_time].round(3)}s"
+      puts "   #{COLORS[:cyan]}Memory:#{COLORS[:reset]} #{memory_usage} MB"
+      
+      if compiled_count > 0
+        puts "   #{COLORS[:cyan]}Status:#{COLORS[:reset]} #{COLORS[:green]}PARTIALLY PRE-COMPILED#{COLORS[:reset]}\n\n"
+      else
+        puts "   #{COLORS[:cyan]}Status:#{COLORS[:reset]} #{COLORS[:yellow]}SECTIONS ONLY#{COLORS[:reset]}\n\n"
+      end
+    end
+
+    def self.memory_usage
+      if Gem.win_platform?
+        # Windows (no `ps -o rss=`)
+        get_windows_memory
+      else
+        # Linux/Mac
+        (`ps -o rss= -p #{Process.pid}`.to_i / 1024.0).round(2)
+      end
+    end
+
+    def self.get_windows_memory
+      memory_kb = `tasklist /FI "PID eq #{Process.pid}" /FO CSV /NH`
+                    .split(",")[4].to_s.gsub('"','').gsub(/[^0-9]/, '').to_i
+      (memory_kb / 1024.0).round(2)
+    end
+
+  end
+end

data/lib/hyraft/cli.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+# hyraft/lib/hyraft/cli.rb
+
+require 'fileutils'
+require 'set'
+
+module Hyraft
+  class CLI
+    def self.start(argv)
+      new(argv).execute
+    end
+
+    def initialize(argv)
+      @argv = argv
+      @command = argv[0]
+      @app_name = argv[1]
+    end
+
+    def execute
+      case @command
+      when "do" 
+        do_application
+      when "version", "-v", "--version"
+        puts "Hyraft version #{VERSION}"
+      when nil, "help", "-h", "--help"
+        show_help
+      else
+        puts "Unknown command: #{@command}"
+        show_help
+      end
+    end
+
+    private
+
+    def show_help
+      puts "Hyraft - Hexagonal Architecture Framework"
+      puts "Commands:"
+      puts "  set APP_NAME    Create a new Hyraft application" 
+      puts "  version         Show version information"
+      puts "  help            Show this help message"
+    end
+
+    def do_application
+      return puts "Error: Need app name" unless @app_name
+      
+      template_dir = find_template_dir
+      unless template_dir && Dir.exist?(template_dir)
+        puts "Error: Could not find template directory"
+        exit 1
+      end
+
+      target_dir = File.expand_path(@app_name)
+      
+      if Dir.exist?(target_dir)
+        puts "Error: Directory '#{@app_name}' already exists"
+        exit 1
+      end
+      
+      puts "Creating Hyraft application: #{@app_name}"
+      copy_template_structure(template_dir, target_dir)
+      ensure_hexagonal_structure(target_dir)
+      create_env_file(target_dir)
+      puts "✅ Hyraft app '#{@app_name}' created successfully!"
+      puts "   cd #{@app_name}"
+      puts "   bundle install && npm install"
+      puts "   hyraft-server thin"
+    end
+
+    def find_template_dir
+      locations = [
+        -> { 
+          gem_spec = Gem::Specification.find_by_name('hyraft')
+          File.join(gem_spec.gem_dir, 'templates', 'do_app')
+        },
+        -> { File.expand_path('../../templates/do_app', __dir__) },
+        -> { File.expand_path('templates/do_app', Dir.pwd) }
+      ]
+      
+      locations.each do |location_proc|
+        begin
+          dir = location_proc.call
+          return dir if Dir.exist?(dir)
+        rescue Gem::LoadError, StandardError
+          next
+        end
+      end
+      
+      nil
+    end
+
+    def copy_template_structure(source, destination)
+      FileUtils.mkdir_p(destination)
+      copy_entire_structure(source, destination)
+    end
+
+    def copy_entire_structure(source, destination)
+      require 'find'
+      copied_paths = Set.new
+      
+      Find.find(source) do |path|
+        next if path == source
+        relative_path = path.sub("#{source}/", '')
+        target_path = File.join(destination, relative_path)
+        next if copied_paths.include?(relative_path)
+        copied_paths.add(relative_path)
+        
+        if File.directory?(path)
+          FileUtils.mkdir_p(target_path)
+          puts "   create #{target_path}/" unless Dir.empty?(path)
+        else
+          FileUtils.mkdir_p(File.dirname(target_path))
+          FileUtils.cp(path, target_path)
+          puts "   create #{target_path}"
+        end
+      end
+    end
+
+    def ensure_hexagonal_structure(app_dir)
+      hex_dirs = [
+        'engine/circuit',
+        'engine/port',
+        'engine/source',
+        'adapter-intake/api-app/request',
+        'adapter-intake/web-app/request',
+        'adapter-exhaust/data-gateway/',
+        'infra/database/migrations',
+        'public/uploads',
+      ]
+      
+      puts "Ensuring hexagonal architecture structure..."
+      
+      hex_dirs.each do |dir|
+        full_path = File.join(app_dir, dir)
+        unless Dir.exist?(full_path)
+          FileUtils.mkdir_p(full_path)
+          puts "   create #{full_path}/" if Dir.empty?(full_path)
+        end
+      end
+    end
+
+    def create_env_file(app_dir)
+      env_path = File.join(app_dir, 'env.yml')
+      
+      env_content = <<~YAML
+# env.yml
+
+# Application Settings
+
+APP_NAME: myapp
+SERVER_PORT: 1091
+SERVER_PORT_API: 1092
+
+development:
+  DB_CONNECTION: mysql
+  DB_HOST: localhost      
+  DB_PORT: 3306           
+  DB_DATABASE: myapp_development
+  DB_USERNAME: root
+  DB_PASSWORD: 
+  DB_CHARSET: utf8mb4
+
+
+test:
+  DB_CONNECTION: mysql
+  DB_HOST: localhost       
+  DB_PORT: 3306
+  DB_DATABASE: myapp_test
+  DB_USERNAME: root
+  DB_PASSWORD: 
+  DB_CHARSET: utf8mb4
+ 
+
+production:
+  DB_CONNECTION: mysql
+  DB_HOST: localhost       
+  DB_PORT: 3306
+  DB_DATABASE: myapp_production
+  DB_USERNAME: 
+  DB_PASSWORD: 
+  DB_CHARSET: utf8mb4
+      YAML
+      
+      File.write(env_path, env_content)
+      puts "   create #{env_path}"
+    end
+  end
+end

data/lib/hyraft/compiler/compiler.rb

@@ -0,0 +1,34 @@
+# lib/hyraft/compiler/compiler.rb
+require_relative 'renderer'
+
+module Hyraft
+  module Compiler
+    class HyraftCompiler
+      def initialize(layout_file)
+        @layout_file = layout_file
+          @renderer = HyraftRenderer.new
+      end
+
+      # compile(view_file, data = {}) -> string
+      def compile(view_file, data = {})
+        layout_content = File.read(@layout_file)
+        parsed = parse_hyraft(view_file)
+        @renderer.render(layout_content, parsed, data)
+      end
+
+      private
+
+      def parse_hyraft(file)
+        content = File.read(file)
+        {
+          displayer:  content[/\<displayer html\>(.*?)\<\/displayer\>/m, 1],
+          transmuter: content[/\<transmuter rb\>(.*?)\<\/transmuter\>/m, 1],
+          styles:     content.scan(/<style\s+src="([^"]+)"\s*\/?>/).flatten, 
+          manifestor: content[/\<manifestor js\>(.*?)\<\/manifestor\>/m, 1],
+          metadata:   content[/\<metadata html\>(.*?)\<\/metadata\>/m, 1],
+          metas:      content[/\<metas html\>(.*?)\<\/metas\>/m, 1]
+        }
+      end
+    end
+  end
+end

data/lib/hyraft/compiler/html_purifier.rb

@@ -0,0 +1,181 @@
+# lib/hyraft/compiler/html_purifier.rb
+module Hyraft
+  module Compiler
+    module HtmlPurifier
+      # Purifies HTML content by escaping dangerous characters to prevent XSS attacks
+      # Usage: purify_html(user_input) - makes any string safe for HTML output
+      def purify_html(unsafe)
+        return '' unless unsafe
+        unsafe.to_s
+          .gsub(/&/, "&")
+          .gsub(/</, "&lt;")
+          .gsub(/>/, "&gt;")
+          .gsub(/"/, "&quot;")
+          .gsub(/'/, "&#039;")
+      end
+      
+      # Alias for purify_html for different use cases
+      def escape_html(unsafe)
+        purify_html(unsafe)
+      end
+      
+      # Additional HTML safety methods
+      def purify_html_attribute(unsafe)
+        return '' unless unsafe
+        unsafe.to_s
+          .gsub(/&/, "&amp;")
+          .gsub(/</, "&lt;")
+          .gsub(/>/, "&gt;")
+          .gsub(/"/, "&quot;")
+          .gsub(/'/, "&#x27;")
+          .gsub(/\//, "&#x2F;")
+      end
+      
+      def purify_javascript(unsafe)
+        return '' unless unsafe
+        unsafe.to_s
+          .gsub(/\\/, "\\\\")
+          .gsub(/'/, "\\'")
+          .gsub(/"/, "\\\"")
+          .gsub(/\n/, "\\n")
+          .gsub(/\r/, "\\r")
+          .gsub(/</, "\\u003C")
+      end
+      
+      # Highlight text with search term while maintaining HTML safety
+      # @param text [String] The text to search within
+      # @param term [String] The search term to highlight
+      # @param highlight_tag [String] HTML tag to use for highlighting (default: 'mark')
+      # @param css_class [String] CSS class to add to highlight tag (optional)
+      # @return [String] Text with highlighted terms
+      def highlight_text(text, term, highlight_tag: 'mark', css_class: nil)
+        return text if term.empty? || text.empty?
+        
+        # First purify the text to make it safe
+        safe_text = purify_html(text)
+        safe_term = purify_html(term)
+        
+        # Escape the term for regex
+        escaped_term = Regexp.escape(safe_term)
+        
+        # Build the opening tag with optional CSS class
+        opening_tag = if css_class
+          "<#{highlight_tag} class=\"#{purify_html_attribute(css_class)}\">"
+        else
+          "<#{highlight_tag}>"
+        end
+        
+        closing_tag = "</#{highlight_tag}>"
+        
+        # Highlight the term
+        safe_text.gsub(/(#{escaped_term})/i) do |match|
+          "#{opening_tag}#{match}#{closing_tag}"
+        end
+      end
+      
+      # Alternative highlighting with span and default Bootstrap classes
+      # @param text [String] The text to search within
+      # @param term [String] The search term to highlight
+      # @param highlight_class [String] CSS class for highlighting (default: 'bg-warning text-dark px-1 rounded')
+      # @return [String] Text with highlighted terms
+      def highlight_with_class(text, term, highlight_class: 'bg-warning text-dark px-1 rounded')
+        highlight_text(text, term, highlight_tag: 'span', css_class: highlight_class)
+      end
+      
+      # ========== HTML HELPER METHODS ==========
+      
+      # Truncate text to specified length
+      # @param text [String] The text to truncate
+      # @param length [Integer] Maximum length before truncation (default: 100)
+      # @param suffix [String] Suffix to add when truncated (default: '...')
+      # @param preserve_words [Boolean] Whether to preserve whole words (default: false)
+      # @return [String] Truncated text
+      def truncate_text(text, length: 100, suffix: '...', preserve_words: false)
+        return '' unless text
+        text = text.to_s
+        
+        if text.length <= length
+          return text
+        end
+        
+        if preserve_words
+          # Try to break at a word boundary
+          truncated = text[0, length]
+          last_space = truncated.rindex(/\s/)
+          
+          if last_space && last_space > length * 0.8  # Only break if we have a reasonable word boundary
+            truncated = text[0, last_space]
+          end
+          
+          truncated + suffix
+        else
+          text[0, length] + suffix
+        end
+      end
+      
+      # Create a safe HTML link
+      # @param text [String] The link text
+      # @param url [String] The link URL
+      # @param attrs [Hash] Additional HTML attributes (e.g., {class: 'btn', target: '_blank'})
+      # @return [String] Safe HTML <a> tag
+      def link_to(text, url, **attrs)
+        # Build attributes string
+        attr_string = attrs.map do |key, value|
+          "#{key}=\"#{purify_html_attribute(value)}\""
+        end.join(' ')
+        
+        attr_string = " #{attr_string}" unless attr_string.empty?
+        
+        "<a href=\"#{purify_html_attribute(url)}\"#{attr_string}>#{purify_html(text)}</a>"
+      end
+      
+      # Format datetime object
+      # @param datetime [Time, DateTime, String] The datetime to format
+      # @param format [String] strftime format string (default: '%Y-%m-%d %H:%M')
+      # @param default [String] Default value if datetime is nil (default: '')
+      # @return [String] Formatted datetime
+      def format_datetime(datetime, format: '%Y-%m-%d %H:%M', default: '')
+        return default unless datetime
+        
+        if datetime.is_a?(String)
+          # Try to parse the string
+          begin
+            datetime = Time.parse(datetime)
+          rescue
+            return default
+          end
+        end
+        
+        if datetime.respond_to?(:strftime)
+          datetime.strftime(format)
+        else
+          default
+        end
+      end
+      
+      # Format a number with commas (e.g., 1000 -> "1,000")
+      # @param number [Numeric, String] The number to format
+      # @param delimiter [String] Thousands delimiter (default: ',')
+      # @param separator [String] Decimal separator (default: '.')
+      # @return [String] Formatted number
+      def number_with_delimiter(number, delimiter: ',', separator: '.')
+        return '' unless number
+        
+        parts = number.to_s.split('.')
+        parts[0] = parts[0].reverse.scan(/\d{1,3}/).join(delimiter).reverse
+        
+        parts.join(separator)
+      end
+      
+      # Pluralize a word based on count
+      # @param count [Integer] The count
+      # @param singular [String] Singular form of the word
+      # @param plural [String] Plural form of the word (optional, will add 's' by default)
+      # @return [String] Pluralized phrase
+      def pluralize(count, singular, plural = nil)
+        plural ||= singular + 's'
+        count == 1 ? "1 #{singular}" : "#{count} #{plural}"
+      end
+    end
+  end
+end