lux-fw 0.2.3 → 0.5.32

data/lib/lux/error/error.rb

@@ -1,91 +1,193 @@
 # frozen_string_literal: true
 
-# 400: for bad parameter request or similar
-BadRequestError   ||= Class.new(StandardError)
+# https://en.wikipedia.org/wiki/List_of_HTTP_status_codes
+
+# default error handler for lux
+# e = Lux::Error.new 404
+# e.code => 404
+# e.message => 'Not Found'
+#
+# e = Lux::Error.not_found('foo')
+# e.code => 404
+# e.message => foo
+
+class Lux::Error < StandardError
+  class AutoRaise < Lux::Error
+  end
 
-# 401: for unauthorized access
-UnauthorizedError ||= Class.new(StandardError)
+  # https://httpstatuses.com/
+  CODE_LIST ||= {
+    # 1×× Informational
+    100 => { name: 'Continue' },
+    101 => { name: 'Switching Protocols' },
+    102 => { name: 'Processing' },
+
+    # 2×× Success
+    200 => { name: 'OK' },
+    201 => { name: 'Created' },
+    202 => { name: 'Accepted' },
+    203 => { name: 'Non-authoritative Information' },
+    204 => { name: 'No Content' },
+    205 => { name: 'Reset Content' },
+    206 => { name: 'Partial Content' },
+    207 => { name: 'Multi-Status' },
+    208 => { name: 'Already Reported' },
+    226 => { name: 'IM Used' },
+
+    # 3×× Redirection
+    300 => { name: 'Multiple Choices' },
+    301 => { name: 'Moved Permanently' },
+    302 => { name: 'Found' },
+    303 => { name: 'See Other' },
+    304 => { name: 'Not Modified' },
+    305 => { name: 'Use Proxy' },
+    307 => { name: 'Temporary Redirect' },
+    308 => { name: 'Permanent Redirect' },
+
+    # 4×× Client Error
+    400 => { name: 'Bad Request', code: :bad_request },
+    401 => { name: 'Unauthorized', code: :unauthorized },
+    402 => { name: 'Payment Required', code: :payment_required },
+    403 => { name: 'Forbidden', code: :forbidden },
+    404 => { name: 'Document Not Found', code: :not_found },
+    405 => { name: 'Method Not Allowed', code: :method_not_allowed },
+    406 => { name: 'Not Acceptable', code: :not_acceptable },
+    407 => { name: 'Proxy Authentication Required' },
+    408 => { name: 'Request Timeout' },
+    409 => { name: 'Conflict' },
+    410 => { name: 'Gone' },
+    411 => { name: 'Length Required' },
+    412 => { name: 'Precondition Failed' },
+    413 => { name: 'Payload Too Large' },
+    414 => { name: 'Request-URI Too Long' },
+    415 => { name: 'Unsupported Media Type' },
+    416 => { name: 'Requested Range Not Satisfiable' },
+    417 => { name: 'Expectation Failed' },
+    418 => { name: 'I\'m a teapot' },
+    421 => { name: 'Misdirected Request' },
+    422 => { name: 'Unprocessable Entity' },
+    423 => { name: 'Locked' },
+    424 => { name: 'Failed Dependency' },
+    426 => { name: 'Upgrade Required' },
+    428 => { name: 'Precondition Required' },
+    429 => { name: 'Too Many Requests' },
+    431 => { name: 'Request Header Fields Too Large' },
+    444 => { name: 'Connection Closed Without Response' },
+    451 => { name: 'Unavailable For Legal Reasons' },
+    499 => { name: 'Client Closed Request' },
+
+    # 5×× Server Error
+    500 => { name: 'Internal Server Error', code: :internal_server_error },
+    501 => { name: 'Not Implemented', code: :not_implemented },
+    502 => { name: 'Bad Gateway' },
+    503 => { name: 'Service Unavailable' },
+    504 => { name: 'Gateway Timeout' },
+    505 => { name: 'HTTP Version Not Supported' },
+    506 => { name: 'Variant Also Negotiates' },
+    507 => { name: 'Insufficient Storage' },
+    508 => { name: 'Loop Detected' },
+    510 => { name: 'Not Extended' },
+    511 => { name: 'Network Authentication Required' },
+    599 => { name: 'Network Connect Timeout Error' },
+  }
+
+  # e = Lux::Error.not_found('foo')
+  CODE_LIST.each do |status, data|
+    if data[:code]
+      define_singleton_method(data[:code]) do |message=nil|
+        error = new status, message
+        raise error if Lux::Error::AutoRaise === error
+        error
+      end
+    end
+  end
 
-# 403: for unalloed access
-ForbidenError     ||= Class.new(StandardError)
+  class << self
+    # template to show full error page
+    def render text, status=500
+      Lux.current.response.status status
+      Lux.current.response.body Lux.config.server_error_template.call(text)
+      throw :done
+    end
 
-# 404: for not found pages
-NotFoundError     ||= Class.new(StandardError)
+    # render error inline or break in production
+    def inline name, error=nil
+      error ||= $!
 
-# 503: for too many requests at the same time
-RateLimitError    ||= Class.new(StandardError)
+      unless Lux.config(:dump_errors)
+        key = log error
+        render "Lux inline error: %s\n\nkey: %s" % [error.message, key]
+      end
 
-module Lux::Error
-  extend self
+      name ||= 'Undefined name'
+      msg    = error.message.to_s.gsub('","',%[",\n "]).gsub('<','&lt;')
 
-  def try name=nil
-    begin
-      yield
-    rescue Exception => e
-      Lux.current.response.status 500
+      dmp = split_backtrace error
 
-      key = log e
+      dmp[0] = dmp[0].map { |_| _ = _.split(':', 3); '<b>%s</b> - %s - %s' % _ }
 
-      if Lux.config(:show_server_errors)
-        inline name
-      else
-        name ||= 'Server error occured'
-        name  += "\n\nkey: %s" % key
+      log error
 
-        Lux.error(name)
-      end
-    end
-  end
+      <<~TEXT
+        <pre style="color:red; background:#eee; padding:10px; font-family:'Lucida Console'; line-height:15pt; font-size:11pt;">
+        <b style="font-size:110%;">#{name}</b>
 
-  def render data
-    %[<html><head><title>Server error (#{Lux.current.response.status})</title></head><body style="background:#fdd;"><pre style="color:red; padding:10px; font-size:14pt;">#{data.gsub('<','&lt;')}</pre></body></html>]
-  end
+        <b>#{error}: #{msg}</b>
 
-  def show desc=nil
-    Lux.current.response.status 500
-    data = "Lux #{Lux.current.response.status} error\n\n#{desc}"
-    Lux.current.response.body! render(data)
-  end
+        #{dmp[0].join("\n")}
 
-  def inline name=nil, o=nil
-    o ||= $!
+        #{dmp[1].join("\n")}
+        </pre>
+      TEXT
+    end
 
-    dmp = [[], []]
+    def report code, msg=nil
+      e = Integer === code ? Lux::Error.new(code) : Lux::Error.send(code)
+      e.message = msg if msg
+      raise e
+    end
 
-    o.backtrace.each do |line|
-      line = line.sub(Lux.root.to_s, '.')
-      dmp[line.include?('/app/') ? 0 : 1].push line
+    def log error
+      Lux.config.error_logger.call error
     end
 
-    dmp[0] = dmp[0].map { |_| _ = _.split(':', 3); '<b>%s</b> - %s - %s' % _ }
+    def split_backtrace error
+      # split app log rest of the log
+      dmp = [[], []]
 
-    name ||= 'Undefined name'
-    msg    = $!.to_s.gsub('","',%[",\n "]).gsub('<','&lt;')
+      root = Lux.root.to_s
 
-    %[<pre style="color:red; background:#eee; padding:10px; font-family:'Lucida Console'; line-height:15pt; font-size:11pt;"><b style="font-size:110%;">#{name}</b>\n\n<b>#{msg}</b>\n\n#{dmp[0].join("\n")}\n\n#{dmp[1].join("\n")}</pre>]
+      error.backtrace.each do |line|
+        line = line.sub(root, '.')
+        dmp[line[0,1] == '.' ? 0 : 1].push line
+      end
+
+      dmp
+    end
   end
 
-  def log exception
-    return if Lux.env         == 'test'
-    return if exception.class == LocalRaiseError
-    return unless Lux.current
+  ###
 
-    # .backtrace.reject{ |el| el.index('/gems/') }
-    history = exception.backtrace
-      .map{ |el| el.sub(Lux.root.to_s, '') }
-      .join("\n")
+  attr_accessor :message
 
-    data = '%s in %s (user: %s)' % [exception.class, Lux.current.request.url, (Lux.current.var.user.email rescue 'guest')]
-    data = [data, exception.message, history].join("\n\n")
-    key  = Digest::SHA1.hexdigest exception.backtrace.first.split(' ').first
+  def initialize code_num, message=nil
+    self.code = code_num
+    @message = message || CODE_LIST[code_num][:name]
+  end
 
-    folder = Lux.root.join('log/exceptions').to_s
-    Dir.mkdir(folder) unless Dir.exists?(folder)
-    folder += "/#{exception.class.to_s.tableize.gsub('/','-')}"
-    Dir.mkdir(folder) unless Dir.exists?(folder)
+  def code
+    # 400 is a default
+    @code || 400
+  end
 
-    File.write("#{folder}/#{key}.txt", data)
+  def code= num
+    @code = num.to_i
 
-    key
+    raise 'Status code %s not found' % @code unless CODE_LIST[@code]
+  end
+
+  def render
+    self.class.render message, code
   end
 end
+

data/lib/lux/event_bus/event_bus.rb

@@ -0,0 +1,27 @@
+# EventBus.on('test') { |arg| puts 'jedan: %s' % arg }
+# EventBus.on('test') { |arg| puts 'dva: %s' % arg }
+# EventBus.on('test') { |arg| raise 'abc' }
+# EventBus.call 'test', 'xxx'
+
+module Lux::EventBus
+  extend self
+
+  EVENTS = {}
+
+  def on name, key=nil, &proc
+    key ||= caller[0].split(':in ').first.gsub(/[^\w]/,'')
+
+    EVENTS[name] ||= {}
+    EVENTS[name][key] ||= proc
+  end
+
+  def call name, opts=nil
+    for func in EVENTS[name].values
+      begin
+        func.call opts
+      rescue => error
+        Lux.config.on_event_bus_error.call error, name
+      end
+    end
+  end
+end

data/lib/lux/lux.rb

@@ -1,50 +1,68 @@
 # frozen_string_literal: true
 
-require_relative '../common/class_callbacks.rb'
+require_relative '../common/class_callbacks'
+require_relative 'cache/cache'
 
-module Lux
+module ::Lux
   extend self
 
-  ENV_PROD    = ENV['RACK_ENV']    == 'production'
-  ENV_DEV     = ENV['RACK_ENV']    == 'development'
-  ENV_TEST    = ENV['RACK_ENV']    == 'test'
-  LUX_CLI     = $0 == 'pry' || $0.index('/run.rb') || ENV['RACK_ENV'] == 'test'
-
-  VERSION = File.read File.expand_path('../../../.version', __FILE__).chomp
-  CONFIG ||= Hashie::Mash.new
-  EVENTS ||= {}
+  ENV_PROD       = ENV['RACK_ENV'] == 'production' unless defined?(ENV_PROD)
+  CACHE_SERVER ||= Lux::Cache.new
+  VERSION      ||= File.read File.expand_path('../../../.version', __FILE__).chomp
+  CONFIG       ||= Hashie::Mash.new
+  APP_ROOT     ||= Pathname.new(Dir.pwd).freeze
+  FW_ROOT      ||= Pathname.new(File.expand_path('../../', File.dirname(__FILE__))).freeze
+  EVENTS       ||= {}
+  MCACHE       ||= {}
 
   BACKGROUND_THREADS ||= []
-  Kernel.at_exit { BACKGROUND_THREADS.each { |t| t.join } }
-
-  define_method(:prod?)  { ENV_PROD }
-  define_method(:dev?)   { ENV_DEV }
-  define_method(:test?)  { ENV_TEST }
-  define_method(:cli?)   { !!($0 =~ %r[/bin/lux$]) }
-  define_method(:thread) { Thread.current[:lux] }
-  define_method(:cache)  { Lux::Cache }
+  # Kernel.at_exit { BACKGROUND_THREADS.each { |t| t.join } }
+
+  define_method(:cli?)         { !@rackup_start }
+  define_method(:test?)        { ENV['RACK_ENV'] == 'test' }
+  define_method(:prod?)        { ENV_PROD }
+  define_method(:production?)  { ENV_PROD }
+  define_method(:dev?)         { !ENV_PROD }
+  define_method(:development?) { !ENV_PROD }
+  define_method(:cache)        { CACHE_SERVER }
+  define_method(:secrets)      { @secrets ||= Lux::Config::Secrets.new.load }
+  define_method(:root)         { APP_ROOT }
+  define_method(:fw_root)      { FW_ROOT }
+  define_method(:event)        { Lux::EventBus }
+  define_method(:require_all)  { |folder| Lux::Config.require_all folder }
 
   # main rack response
   def call env=nil
     state  = Lux::Current.new env
     app    = Lux::Application.new state
     app.render
-  rescue => e
-    raise e if Lux.config(:show_server_errors)
-
-    [500, {}, ['Lux server error']]
+  rescue => error
+    if Lux.config(:dump_errors)
+      raise error
+    else
+      log error.backtrace
+      [500, {}, ['Server error: %s' % error.message]]
+    end
   end
 
   def env key=nil
-    return ENV['RACK_ENV'] unless key
-    die "ENV['#{key}'] not found" if ENV[key].nil?
-    ENV[key]
+    if key
+      value = ENV[key]
+      die "ENV['#{key}'] not found" if value.nil?
+      value
+    else
+      ENV['RACK_ENV']
+    end
   end
 
   def config key=nil
-    return CONFIG unless key
-    die 'Lux.config.%s not found' % key if CONFIG[key].nil?
-    CONFIG[key].kind_of?(Proc) ? CONFIG[key].call() : CONFIG[key]
+    if key
+      value = CONFIG[key]
+      die 'Lux.config.%s not found' % key if value.nil?
+      value.kind_of?(Proc) ? value.call() : value
+    else
+      CONFIG
+    end
   end
 
   def current
@@ -59,43 +77,39 @@ module Lux
     block ? Lux::Application.class_eval(&block) : Lux::Application
   end
 
-  def root
-    @@lux_app_root ||= Pathname.new(Dir.pwd).freeze
-  end
-
-  def fw_root
-    @@lux_fw_root ||= Pathname.new(File.expand_path('../../', File.dirname(__FILE__))).freeze
+  def error data=nil
+    data ? Lux::Error.render(data) : Lux::Error
   end
 
-  def error data
-    current.response.status 500
-    Lux::Error.show(data)
-  end
-
-  def log what
+  # simple log to stdout
+  def log what=nil
     return unless Lux.config(:log_to_stdout)
-    puts what
+    puts what || yield
   end
 
-  def on name, ref=nil, &proc
-    EVENTS[name] ||= []
-
-    if block_given?
-      puts "* event: #{name} defined".white
-      EVENTS[name].push(proc)
-    else
-      for func in EVENTS[name]
-        ref.instance_eval(&func)
-      end
-    end
+  # simple interface to plugins
+  # Lux.plugin :foo
+  # Lux.plugin
+  def plugin *args
+    args.first ? Lux::Config::Plugin.load(*args) : Lux::Config::Plugin
   end
 
   # if block given, simple new thread bg job
   # if string given, eval it in bg
   # if object given, instance it and run it
-  def delay *args
+  def delay *args, &block
     if block_given?
-      BACKGROUND_THREADS.push Thread.new { yield }
+      puts 'add'
+
+      t = Thread.new do
+        begin
+          block.call
+        rescue => e
+          Lux.logger(:delay_errors).error [e.message, e.backtrace]
+        end
+      end
+
+      BACKGROUND_THREADS.push t
     elsif args[0]
       # Lux.delay(mail_object, :deliver)
       Lux::DelayedJob.push(*args)
@@ -104,23 +118,46 @@ module Lux
     end
   end
 
-  def speed loops=1
+  # load rake tasks + including ones in plugins
+  def load_tasks
+    require_relative '../../tasks/loader.rb'
+  end
+
+  # in memory cache, used on app init, no need for Mutex
+  def ram_cache key
+    MCACHE[key] = nil if Lux.config(:compile_assets)
+    MCACHE[key] ||= yield
+  end
+
+  # initialize the Lux application
+  def start
+    Lux.config.lux_config_loaded = true
+
+    Config.start!
+  end
+
+  # must be called when serving web pages from rackup
+  def serve rack_handler
+    @rackup_start = true
+    Object.class_callback :web_boot, Lux::Application, rack_handler
+    rack_handler.run self
+  end
+
+  # simple block to calc block execution speed
+  def speed
     render_start = Time.monotonic
-    loops.times { yield }
+    yield
     num = (Time.monotonic - render_start) * 1000
-    num = "#{num.round(1)} ms"
-    loops == 1 ? num : "Done #{loops.to_s.sub(/(\d)(\d{3})$/,'\1s \2')} loops in #{num}"
+    '%s ms' % num.round(1)
   end
 
-  # load specific plugin
-  def plugin name
-    dir  = '%s/plugins/%s' % [Lux.fw_root, name]
-    base = '%s/base.rb' % dir
+  # Lux.logger(:foo).warn 'bar'
+  def logger name=nil
+    name ||= ENV.fetch('RACK_ENV').downcase
 
-    if File.exist?(base)
-      load base
-    else
-      Lux::Config.require_all('%s/*' % dir)
+    MCACHE['lux-logger-%s' % name] ||=
+    Logger.new('./log/%s.log' % name).tap do |it|
+      it.formatter = Lux.config.logger_formater
     end
   end
 end

data/lib/lux/mailer/mailer.rb

@@ -1,31 +1,32 @@
 # sugessted usage
-# Mailer.deliver(:confirm_email, 'rejotl@gmailcom')
-# Mailer.render(:confirm_email, 'rejotl@gmailcom')
+# Mailer.deliver(:email_login, 'foo@bar.baz')
+# Mailer.render(:email_login, 'foo@bar.baz')
 
 # natively works like
-# Mailer.prepare(:confirm_email, 'rejotl@gmailcom').deliver
-# Mailer.prepare(:confirm_email, 'rejotl@gmailcom').body
+# Mailer.prepare(:email_login, 'foo@bar.baz').deliver
+# Mailer.prepare(:email_login, 'foo@bar.baz').body
 
 # Rails mode via method missing is suported
-# Mailer.confirm_email('rejotl@gmailcom').deliver
-# Mailer.confirm_email('rejotl@gmailcom').body
+# Mailer.email_login('foo@bar.baz').deliver
+# Mailer.email_login('foo@bar.baz').body
 
 class Lux::Mailer
-  ClassCallbacks.define self, :before, :after
+  class_callback :before
+  class_callback :after
+
   class_attribute :helper
+  class_attribute :layout, 'mailer'
 
   attr_reader :mail
 
   class << self
-    # Mailer.prepare(:confirm_email, 'rejotl@gmailcom')
+    # Mailer.prepare(:email_login, 'foo@bar.baz')
     def prepare template, *args
       obj = new
       obj.instance_variable_set :@_template, template
-
-      ClassCallbacks.execute obj, :before
+      Object.class_callback :before, obj
       obj.send template, *args
-      ClassCallbacks.execute obj, :after
-
+      Object.class_callback :after, obj
       obj
     end
 
@@ -45,7 +46,7 @@ class Lux::Mailer
   ###
 
   def initialize
-    @mail = DynamicClass.new subject: nil, body: nil, to: nil, cc: nil, from: nil
+    @mail = FreeStruct.new subject: nil, body: nil, to: nil, cc: nil, from: nil
   end
 
   def deliver
@@ -53,30 +54,27 @@ class Lux::Mailer
     raise "To in mailer not defined"      unless @mail.to
     raise "Subject in mailer not defined" unless @mail.subject
 
-    require 'mail'
-
-    Mail.defaults { delivery_method Lux.config(:mail).delivery, Lux.config(:mail).opts }
-
     m = Mail.new
     m[:from]         = @mail.from
     m[:to]           = @mail.to
     m[:subject]      = @mail.subject
-    m[:body]         = @mail.body || body
+    m[:body]         = body
     m[:content_type] = 'text/html; charset=UTF-8'
 
-    Thread.new { m.deliver! }
-  end
+    Lux.delay { m.deliver! }
 
-  def deliver_later
-     Lux.delay self, :deliver
+    instance_exec m, &Lux.config.on_mail
   end
 
   def body
-    return @mail.body if @mail.body
+    data = @mail.body
 
-    helper = Lux::Helper.new self, self.class.helper
+    unless data
+      helper = Lux::View::Helper.new self, self.class.helper
+      data = Lux::View.render_with_layout "layouts/#{self.class.layout}", "mailer/#{@_template}", helper
+    end
 
-    Lux::Template.render_with_layout "mailer/#{@_template}", helper
+    data.gsub(%r{\shref=(['"])/}) { %[ href=#{$1}#{Lux.config.host}/] }
   end
 
   def subject

data/lib/lux/response/lib/file.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+class Lux::Response::File
+  MIMME_TYPES = {
+    txt:  'text/plain',
+    html: 'text/html',
+    gif:  'image/gif',
+    jpg:  'image/jpeg',
+    jpeg: 'image/jpeg',
+    png:  'image/png',
+    ico:  'image/png', # image/x-icon
+    css:  'text/css',
+    map:  'application/json',
+    js:   'application/javascript',
+    gz:   'application/x-gzip',
+    zip:  'application/x-gzip',
+    svg:  'image/svg+xml',
+    mp3:  'application/mp3',
+    woff:  'application/x-font-woff',
+    woff2: 'application/x-font-woff',
+    ttf:   'application/font-ttf',
+    eot:   'application/vnd.ms-fontobject',
+    otf:   'application/font-otf',
+    doc:   'application/msword'
+  }
+
+  ###
+  # all parametars are optional
+  # :name          - file name
+  # :cache         - client cache in seconds
+  # :content_type  - string type
+  # :inline        - sets disposition to inline if true
+  # :disposition   - inline or attachment
+  # :content       - raw file data
+  def initialize file, in_opts={}
+    opts = in_opts.to_opts :name, :cache, :content_type, :inline, :disposition, :content
+    opts.disposition ||= opts.inline.class == TrueClass ? 'inline' : 'attachment'
+    opts.cache         = true if opts.cache.nil?
+
+    file = 'public/%s' % file unless file[0, 1] == '/'
+
+    @ext  = file.include?('.') ? file.split('.').last.to_sym : nil
+    @file = file
+    @opts = opts
+  end
+
+  define_method(:request)  { Lux.current.request }
+  define_method(:response) { Lux.current.response }
+
+  def is_static_file?
+    return false unless @ext
+    File.exist?(@file)
+  end
+
+  def send
+    file = File.exist?(@file) ? @file : Lux.root.join("public#{@file}").to_s
+
+    raise Lux::Error.not_found('Static file not found') unless File.exists?(file)
+
+    response.content_type(@opts.content_type || MIMME_TYPES[@ext || '_'] || 'application/octet-stream')
+
+    file_mtime = File.mtime(file).utc.to_s
+    key        = Crypt.sha1(file + (@opts.content || file_mtime.to_s))
+
+    if @opts.disposition == 'attachment'
+      @opts.name ||= @file.split('/').last
+      response.headers['content-disposition'] = 'attachment; filename=%s' % @opts.name
+    end
+
+    response.headers['cache-control'] = 'max-age=%d, public' % (@opts.cache ? 31536000 : 0)
+    response.headers['etag']          = '"%s"' % key
+    response.headers['last-modified'] = file_mtime
+
+    # IF etags match, returnfrom cache
+    if request.env['HTTP_IF_NONE_MATCH'] == key
+      response.body('not-modified', 304)
+    else
+      response.body @opts.content || File.read(file)
+    end
+  end
+end