rubelith 0.1.0

data/lib/rubelith/application.rb

@@ -0,0 +1,591 @@
+    # --- Enterprise/Niche Features ---
+    def policy_for(user, record, action)
+      # Stub: Pundit-style policy check
+      policy_class = Object.const_get("#{record.class}Policy") rescue nil
+      if policy_class && policy_class.respond_to?(:new)
+        policy = policy_class.new(user, record)
+        policy.respond_to?(action) ? policy.send(action) : false
+      else
+        false
+      end
+    end
+
+    def encrypt_field(value, key: 'rubelith_default_key')
+      require 'openssl'
+      cipher = OpenSSL::Cipher.new('AES-256-CBC')
+      cipher.encrypt
+      cipher.key = Digest::SHA256.digest(key)
+      iv = cipher.random_iv
+      encrypted = cipher.update(value.to_s) + cipher.final
+      [encrypted, iv].map { |v| [v].pack('m') }.join('--')
+    end
+
+    def decrypt_field(encrypted, key: 'rubelith_default_key')
+      require 'openssl'
+      encrypted, iv = encrypted.split('--').map { |v| v.unpack1('m') }
+      cipher = OpenSSL::Cipher.new('AES-256-CBC')
+      cipher.decrypt
+      cipher.key = Digest::SHA256.digest(key)
+      cipher.iv = iv
+      cipher.update(encrypted) + cipher.final
+    end
+
+    def register_validator(name, &block)
+      @custom_validators ||= {}
+      @custom_validators[name] = block
+      puts "Validator '#{name}' registered."
+    end
+
+    def validate_custom(name, value)
+      if @custom_validators && @custom_validators[name]
+        @custom_validators[name].call(value)
+      else
+        false
+      end
+    end
+
+    # LithBlade rendering
+    def render_lithblade(template_path, context = {})
+      LithBlade.render(template_path, context)
+    end
+
+    def add_database(name, config)
+      @databases ||= {}
+      @databases[name] = config
+      puts "Database '#{name}' added."
+    end
+
+    def get_database(name)
+      @databases ? @databases[name] : nil
+    end
+
+    def enqueue_priority(job_class, *args, priority: :normal)
+      @priority_queue ||= Hash.new { |h, k| h[k] = [] }
+      @priority_queue[priority] << { job: job_class, args: args }
+      puts "Job enqueued with priority #{priority}: #{job_class}"
+    end
+
+    def run_priority_jobs!
+      (@priority_queue || {}).each do |_priority, jobs|
+        jobs.each do |job|
+          Thread.new { job[:job].new.perform(*job[:args]) }
+        end
+      end
+      puts 'Priority jobs executed.'
+    end
+
+    def generate_api_docs!
+      docs_path = File.join(Dir.pwd, 'docs')
+      Dir.mkdir(docs_path) unless Dir.exist?(docs_path)
+      File.write(File.join(docs_path, 'openapi.yml'), "# OpenAPI/Swagger docs (stub)")
+      puts 'API documentation generated.'
+    end
+
+    def replay_request(env)
+      puts "Replaying request: #{env.inspect}"
+      call(env)
+    end
+
+    def headless_mode!
+      @headless = true
+      puts 'Headless API mode enabled.'
+    end
+
+    def repl!
+      require 'irb'
+      puts 'Starting Rubelith REPL...'
+      IRB.start
+    end
+
+    def integrate_with(service, config = {})
+      @integrations ||= {}
+      @integrations[service] = config
+      puts "Integrated with #{service}."
+    end
+    # --- Advanced Features ---
+    def hot_reload!
+      # Stub: Reload code/assets in development
+      puts 'Hot reloading enabled.'
+    end
+
+    def service_container
+      @services ||= {}
+    end
+
+    def register_service(name, instance)
+      service_container[name] = instance
+      puts "Service '#{name}' registered."
+    end
+
+    def background_job(job_class, *args)
+      Thread.new { job_class.new.perform(*args) }
+      puts "Background job enqueued: #{job_class}"
+    end
+
+    def rate_limit!(key, limit: 100, period: 60)
+      @rate_limits ||= {}
+      now = Time.now.to_i / period
+      @rate_limits[key] ||= { count: 0, window: now }
+      if @rate_limits[key][:window] != now
+        @rate_limits[key] = { count: 1, window: now }
+      else
+        @rate_limits[key][:count] += 1
+      end
+      allowed = @rate_limits[key][:count] <= limit
+      puts "Rate limit for '#{key}': #{allowed ? 'allowed' : 'blocked'}"
+      allowed
+    end
+
+    def audit_log(event, data = {})
+      @audit_logs ||= []
+      @audit_logs << { event: event, data: data, timestamp: Time.now }
+      puts "Audit log: #{event}"
+    end
+
+    def render_error_page(status)
+      puts "Rendering error page for status #{status}"
+      "<h1>Error #{status}</h1>"
+    end
+
+    def upload_file(file, dest)
+      File.write(dest, file.read)
+      puts "File uploaded to #{dest}"
+    end
+
+    def oauth_login(provider)
+      puts "OAuth2 login with #{provider} (stub)"
+    end
+
+    def graphql_query(*)
+      puts "GraphQL query executed (stub)"
+      {}
+    end
+
+    def generate_admin_panel!
+      puts 'Admin panel generated (stub).'
+    end
+
+    def health_check!
+      puts 'Health check passed.'
+      true
+    end
+
+    def enable_multi_tenancy!
+      puts 'Multi-tenancy enabled.'
+    end
+
+    def search(query)
+      puts "Search executed for: #{query} (stub)"
+      []
+    end
+
+    def send_notification(type, message)
+      puts "Notification sent: [#{type}] #{message}"
+    end
+
+    def set_template_engine(engine)
+      @template_engine = engine
+      puts "Template engine set to #{engine}"
+    end
+
+    def generate_static_site!
+      puts 'Static site generated (stub).'
+    end
+
+    def api_throttle!(key, limit: 100, period: 60)
+      rate_limit!(key, limit: limit, period: period)
+    end
+
+    def add_cli_generator(name, &block)
+      @cli_generators ||= {}
+      @cli_generators[name] = block
+      puts "CLI generator '#{name}' added."
+    end
+
+    def feature_flag(name, enabled)
+      @feature_flags ||= {}
+      @feature_flags[name] = enabled
+      puts "Feature flag '#{name}' set to #{enabled}"
+    end
+
+    def containerize!
+      puts 'Containerization support enabled (stub).'
+    end
+    def schedule_tasks!
+      # Example: Run scheduled jobs (stub)
+      puts 'Scheduled tasks executed.'
+    end
+
+    def process_assets!
+      assets_dir = File.join(Dir.pwd, 'public', 'assets')
+      Dir.mkdir(assets_dir) unless Dir.exist?(assets_dir)
+      # Stub: Minify, bundle, version assets
+      puts 'Assets processed.'
+    end
+
+    def start_websockets!
+      # Stub: Start WebSocket server
+      puts 'WebSocket server started.'
+    end
+
+    def enable_api_mode!
+      # Stub: Enable API mode
+      puts 'API mode enabled.'
+    end
+
+    def manage_translations!
+      # Stub: Update translations
+      puts 'Translations updated.'
+    end
+
+    def monitor_app!
+      # Stub: Start monitoring
+      puts 'Monitoring active.'
+    end
+
+    def track_analytics!
+      # Stub: Track analytics
+      puts 'Analytics tracked.'
+    end
+
+    def manage_sessions!
+      # Stub: Manage sessions
+      puts 'Sessions managed.'
+    end
+    def seed!
+      seed_path = File.expand_path('../../db/seeds.rb', __dir__)
+      if File.exist?(seed_path)
+        require seed_path
+        puts 'Database seeded.'
+      else
+        puts 'No seeds.rb file found.'
+      end
+    end
+
+    def clear_cache!
+      @cache = {} if instance_variable_defined?(:@cache)
+      cache_file = File.join(Dir.pwd, 'tmp', 'config_cache.yml')
+      File.delete(cache_file) if File.exist?(cache_file)
+      puts 'Cache cleared.'
+    end
+
+    def generate_docs!
+      docs_path = File.join(Dir.pwd, 'docs')
+      Dir.mkdir(docs_path) unless Dir.exist?(docs_path)
+      File.write(File.join(docs_path, 'README.md'), "# Rubelith Documentation\n\nAuto-generated docs.")
+      puts 'Documentation generated.'
+    end
+
+    def trigger_event!(event_name, data = {})
+      @events ||= []
+      @events << { name: event_name, data: data, timestamp: Time.now }
+      puts "Event '#{event_name}' triggered."
+    end
+
+require "rack" # rubocop:disable Style/StringLiterals
+require "zeitwerk" # rubocop:disable Style/StringLiterals
+require_relative "../../core/router" # rubocop:disable Style/StringLiterals
+
+module Rubelith
+  class Application # rubocop:disable Metrics/ClassLength,Style/Documentation
+    # LithBlade rendering
+    def render_lithblade(template_path, context = {})
+      LithBlade.render(template_path, context)
+    end
+    # --- Powerful Middleware System ---
+    class MiddlewareStack
+      def initialize
+        @stack = []
+      end
+      def use(mw) # rubocop:disable Layout/EmptyLineBetweenDefs,Naming/MethodParameterName
+        @stack << mw
+      end
+      def call(env) # rubocop:disable Layout/EmptyLineBetweenDefs
+        @stack.reverse.inject(->(e) { Rubelith.application.router.dispatch(e) }) do |app, mw|
+          mw.respond_to?(:call) ? ->(e) { mw.call(e, app) } : app
+        end.call(env)
+      end
+    end
+
+    # --- Powerful Auth Functionality ---
+    require 'jwt'
+    require 'bcrypt'
+
+    def generate_jwt(payload, secret = ENV['RUBELITH_JWT_SECRET'])
+      raise 'JWT secret must be set in ENV for production!' unless secret && secret != 'rubelith_secret'
+      JWT.encode(payload, secret, 'HS256')
+    end
+
+    def decode_jwt(token, secret = ENV['RUBELITH_JWT_SECRET'])
+      return nil unless secret && secret != 'rubelith_secret'
+      JWT.decode(token, secret, true, algorithm: 'HS256')[0]
+    rescue JWT::DecodeError
+      nil
+    end
+
+    def hash_password(password)
+      BCrypt::Password.create(password)
+    end
+
+    def valid_password?(hash, password)
+      BCrypt::Password.new(hash) == password
+    end
+
+    def current_user(env)
+      token = env['HTTP_AUTHORIZATION']&.split(' ')&.last
+      payload = decode_jwt(token)
+      @models['User']&.find_by_id(payload['user_id']) if payload && @models['User']
+    end
+
+    def authorize!(env, roles: [:user])
+      user = current_user(env)
+      return false unless user
+
+      (user.roles & roles).any?
+    end
+
+    # --- Powerful Sass Engine Integration ---
+    require 'sassc'
+
+    def compile_sass(scss_path)
+      # Validate path to prevent directory traversal
+      abs_path = File.expand_path(scss_path, Dir.pwd)
+      return '' unless abs_path.start_with?(File.expand_path('public/', Dir.pwd))
+      engine = SassC::Engine.new(File.read(abs_path), syntax: :scss)
+      engine.render
+    end
+
+    def serve_sass(env)
+      req = Rack::Request.new(env)
+      if req.path_info.end_with?('.css')
+        scss_path = File.expand_path(File.join('public', req.path_info.sub(/\.css$/, '.scss')), Dir.pwd)
+        if File.exist?(scss_path)
+          css = compile_sass(scss_path)
+          return [200, { 'Content-Type' => 'text/css' }, [css]]
+        end
+      end
+      nil
+    end
+
+    # Sass middleware is now optional. To enable, add:
+    # use lambda { |env, app| result = serve_sass(env); result || app.call(env) }
+    def t(key, locale: :en)
+      require 'yaml'
+      @translations ||= {}
+      unless @translations[locale]
+        path = File.expand_path("../../config/locales/#{locale}.yml", __dir__)
+        @translations[locale] = File.exist?(path) ? YAML.load_file(path) : {}
+      end
+      @translations[locale][key.to_s] || key.to_s
+    end
+
+    def register_plugin(plugin)
+      @plugins ||= []
+      @plugins << plugin
+      plugin.load(self) if plugin.respond_to?(:load)
+    end
+
+    def run_tests
+      require 'minitest'
+      puts 'Running tests...'
+      Minitest.run
+    end
+
+    def cache(key, value = nil, expires_in: 3600) # rubocop:disable Metrics/MethodLength
+      require 'monitor'
+      @cache_mutex ||= Monitor.new
+      @cache ||= {}
+      @cache_mutex.synchronize do
+        if value
+          @cache[key] = { value: value, expires_at: Time.now + expires_in }
+        else
+          entry = @cache[key]
+          if entry && entry[:expires_at] > Time.now
+            entry[:value]
+          else
+            @cache.delete(key)
+            nil
+          end
+        end
+      end
+    end
+
+    def cluster(nodes)
+      @cluster_nodes ||= []
+      @cluster_nodes.concat(nodes).uniq!
+    end
+
+    def log(message, level: :info)
+      levels = { debug: 0, info: 1, warn: 2, error: 3 }
+      @log_level ||= :debug
+      return unless levels[level] >= levels[@log_level]
+
+      puts "[#{level.upcase}] #{Time.now}: #{message}"
+    end
+
+    def monitor(event, data = {})
+      @monitor_events ||= []
+      @monitor_events << { event: event, data: data, timestamp: Time.now }
+      # Integrate with external monitoring tools here
+    end
+
+    def track_analytics(event, data = {})
+      @analytics_events ||= []
+      @analytics_events << { event: event, data: data, timestamp: Time.now }
+      # Integrate with analytics providers here
+    end
+
+    def authenticate(req)
+      # Simple session-based authentication
+      session = req.env['rack.session'] || {}
+      user_id = session[:user_id]
+      @models['User']&.find_by_id(user_id) if user_id
+    end
+
+    def authorize(user, action, _resource)
+      # Simple role-based authorization
+      return false unless user
+
+      roles = user.respond_to?(:roles) ? user.roles : [:guest]
+      # Example: allow admin all actions
+      roles.include?(:admin) || action == :read
+    end
+
+    def protect_from_csrf(req, res)
+      session = req.env['rack.session'] || {}
+      token = req.params['_csrf']
+      valid = token && session[:csrf_token] == token
+      res.status = 403 unless valid
+      valid
+    end
+
+    def protect_from_xss(content)
+      # Basic sanitizer: remove script tags
+      content.gsub(%r{<script.*?>.*?</script>}im, '[removed]')
+    end
+
+    def enqueue(job_class, *args)
+      @job_queue ||= Queue.new
+      Thread.new do
+        job_class.new.perform(*args) if job_class.respond_to?(:new)
+      end
+      @job_queue << { job: job_class, args: args }
+    end
+
+    def deliver_mail(mailer_class, method, *args)
+      require 'net/smtp'
+      mailer = mailer_class.new
+      mail = mailer.send(method, *args) if mailer.respond_to?(method)
+      if mail.respond_to?(:to_s)
+        # Example SMTP delivery (customize as needed)
+        Net::SMTP.start('localhost', 25) do |smtp|
+          smtp.send_message mail.to_s, mail.from, mail.to
+        end
+      end
+      mail
+    end
+
+    def migrate! # rubocop:disable Metrics/MethodLength
+      migrations_path = File.expand_path('../../db/migrations', __dir__)
+      return unless Dir.exist?(migrations_path)
+
+      Dir[File.join(migrations_path, '*.rb')].sort.each do |file|
+        require file
+        migration_class = begin
+          Object.const_get(camelize(File.basename(file, '.rb')))
+        rescue StandardError
+          nil
+        end
+        migration_class.new.change if migration_class.respond_to?(:change)
+      end
+    end
+
+    def define_relation(model, relation_type, related_model, options = {})
+      @relations ||= {}
+      @relations[model] ||= []
+      @relations[model] << { type: relation_type, related: related_model, options: options }
+    end
+
+    def validate(model, field, validator, options = {})
+      @validations ||= {}
+      @validations[model] ||= []
+      @validations[model] << { field: field, validator: validator, options: options }
+    end
+    attr_reader :config, :middleware_stack, :models, :router
+
+    def initialize
+      @config = load_config
+      @middleware_stack = MiddlewareStack.new
+      @models = {}
+      @router = Rubelith::Router.new
+      load_models
+    end
+
+    def load_models # rubocop:disable Metrics/MethodLength
+      models_path = File.expand_path('../../app/models', __dir__)
+      return unless Dir.exist?(models_path)
+
+      Dir[File.join(models_path, '*.rb')].each do |file|
+        require file
+        model_name = File.basename(file, '.rb')
+        @models[camelize(model_name)] = begin
+          Object.const_get(camelize(model_name))
+        rescue StandardError
+          nil
+        end
+      end
+    end
+
+    def call(env)
+      @middleware_stack.call(env)
+    end
+
+    def route(method, path, to: nil, &block)
+      action = block || to
+      # Wrap block to always accept 3 args (req, res, _params)
+      if action.is_a?(Proc) && action.arity < 3
+        wrapped = ->(req, res, _params = {}) { action.call(req, res) }
+        @router.add_route(method, path, wrapped)
+      else
+        @router.add_route(method, path, action)
+      end
+    end
+
+    def use(mw)
+      @middleware_stack.use(mw)
+    end
+
+    # build_middleware_stack is now handled by MiddlewareStack
+
+    # Removed legacy dispatch/invoke_action. Use @router for all routing.
+
+    def before_dispatch(req, res)
+      # Hook for custom logic before dispatch
+    end
+
+    def after_dispatch(req, res)
+      # Hook for custom logic after dispatch
+    end
+
+    def camelize(str)
+      str.split('_').map(&:capitalize).join
+    end
+
+    private
+
+    require 'yaml'
+    def load_config
+      config_path = File.expand_path('../../config/application.yml', __dir__)
+      config = {}
+      if File.exist?(config_path)
+        config_data = YAML.safe_load(File.read(config_path), permitted_classes: [Symbol]) rescue {}
+        config.merge!(config_data) if config_data.is_a?(Hash)
+      end
+      config
+    end
+
+    def setup_autoloader
+      # Zeitwerk loader is set up in lib/rubelith.rb
+    end
+  end
+end

data/lib/rubelith/crystallis.rb

@@ -0,0 +1,12 @@
+# Crystallis ORM entry point for Rubelith
+require_relative '../../core/crystallis/base'
+require_relative '../../core/crystallis/migration'
+require_relative '../../core/crystallis/relation'
+require_relative '../../core/crystallis/schema'
+require_relative '../../core/crystallis/validators'
+
+module Rubelith
+  module Crystallis
+    # Crystallis ORM is loaded via its core modules
+  end
+end

data/lib/rubelith/version.rb

@@ -0,0 +1,52 @@
+# lib/rubelith/version.rb
+
+module Rubelith
+  module Version
+    MAJOR = 0
+    MINOR = 1
+    PATCH = 0
+    PRERELEASE = nil
+
+    def self.to_s
+      [MAJOR, MINOR, PATCH].join('.') + (PRERELEASE ? "-#{PRERELEASE}" : "")
+    end
+
+    def self.bump(type = :patch)
+      case type
+      when :major
+        self.const_set(:MAJOR, MAJOR + 1)
+        self.const_set(:MINOR, 0)
+        self.const_set(:PATCH, 0)
+      when :minor
+        self.const_set(:MINOR, MINOR + 1)
+        self.const_set(:PATCH, 0)
+      when :patch
+        self.const_set(:PATCH, PATCH + 1)
+      end
+    end
+
+    def self.changelog
+      @changelog ||= []
+    end
+
+    def self.add_change(description)
+      changelog << { version: to_s, description: description, timestamp: Time.now }
+    end
+
+    def self.upgrade_to(version)
+      # Placeholder for upgrade logic
+      # Example: upgrade_to('1.2.0')
+      # Would run migrations, update configs, etc.
+      "Upgraded to #{version}"
+    end
+
+    def self.downgrade_to(version)
+      # Placeholder for downgrade logic
+      # Example: downgrade_to('0.9.0')
+      # Would rollback migrations, restore configs, etc.
+      "Downgraded to #{version}"
+    end
+  end
+
+  VERSION = Version.to_s
+end