lux-fw 0.1.35 → 0.2.1

data/lib/lux/helper/helper.rb

@@ -1,48 +1,44 @@
 # frozen_string_literal: true
 
-# plugins should extend this
-module DefaultHelper
-end
-
 class Lux::Helper
 
-  class << self
-    def for group, locals={}, &block
-      base_class_helper = if [Symbol, String].include?(group.class)
-        "#{group}_helper".classify.constantize
-      elsif group
-        group
-      end
+  # create helper object that cah be used in template render
+  def initialize instance, *list
+    extend ApplicationHelper
 
-      helper = Lux::Helper.new
-      helper.extend DefaultHelper
-      helper.extend base_class_helper if base_class_helper
-
-      # locals overide globals
-      for k, v in locals
-        helper.instance_variable_set("@#{k.to_s.sub('@','')}", v)
-      end
+    list.flatten.compact.each do |el|
+      el = el.to_s.classify+'Helper'
+      extend el.constantize
+    end
 
-      return helper.instance_exec &block if block
+    local_vars = instance.class == Hash ? instance : instance.instance_variables_hash
 
-      helper
+    # locals overide globals
+    for k, v in local_vars
+      instance_variable_set("@#{k.to_s.sub('@','')}", v)
     end
+
+    # helper.instance_exec &block if block
   end
 
   def no_white_space
     yield.gsub(/>\s+</,'><')
   end
 
-  def page
-    Lux.page
+  def current
+    Lux.current
   end
 
   def request
-    Lux.page.request
+    Lux.current.request
   end
 
   def params
-    Lux.page.params
+    Lux.current.params
+  end
+
+  def nav
+    Lux.current.nav
   end
 
   # renders just template but it is called
@@ -62,17 +58,16 @@ class Lux::Helper
       name = "#{Thread.current[:lux][:last_template_path]}/#{name}" unless name.index('/')
     end
 
-    ivh = instance_variables_hash
-
     for k, v in locals
-      ivh["@_#{k}"] = v
+      instance_variable_set("@_#{k}", v)
     end
 
     if block_given?
       name = "#{name}/layout" unless name.index('/')
-      Lux::Template.new(name, ivh).render_part { yield }
+
+      Lux::Template.new(name, self).render_part { yield }
     else
-      Lux::Template.new(name, ivh).render_part
+      Lux::Template.new(name, self).render_part
     end
   end
 
@@ -93,17 +88,17 @@ class Lux::Helper
     klass.cell(action, *args) rescue error("#{klass}.#{action}()\n\n#{$!.message}")
   end
 
-  # add locale prefix if using locale
-  def localize path
-    return Lux.config(:localize) ? "/#{Locale.current}#{path}" : path
-  end
-
   # tag :div, { 'class'=>'iform' } do
   def tag name=nil, opts={}, data=nil
-    return Lux::Helper::HtmlTag unless name
+    return HtmlTagBuilder unless name
 
     data = yield(opts) if block_given?
-    Lux::Helper::HtmlTag.tag name, opts, data
+    HtmlTagBuilder.tag name, opts, data
+  end
+
+  # helper(:main).method
+  def helper *names
+    Lux::Helper.new(self, *names)
   end
 
 end

data/lib/lux/helper/helpers/application_helper.rb

@@ -0,0 +1,3 @@
+# allways included
+module ApplicationHelper
+end

data/lib/lux/helper/helpers/html_helper.rb

@@ -0,0 +1,3 @@
+module HtmlHelper
+
+end

data/lib/lux/helper/helpers/mailer_helper.rb

@@ -0,0 +1,11 @@
+module MailerHelper
+  extend self
+
+  def mail
+    @mail
+  end
+
+  def host
+    ENV.fetch('HOST')
+  end
+end

data/lib/lux/lux.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
+require_relative '../common/class_callbacks.rb'
+
 module Lux
   extend self
 
   ENV_PROD    = ENV['RACK_ENV']    == 'production'
   ENV_DEV     = ENV['RACK_ENV']    == 'development'
   ENV_TEST    = ENV['RACK_ENV']    == 'test'
-  LUX_LIVE    = ENV['LUX_LIVE']    == 'true'
-  LUX_VERBOSE = ENV['LUX_VERBOSE'] == 'true'
   LUX_CLI     = $0 == 'pry' || $0.index('/run.rb') || ENV['RACK_ENV'] == 'test'
 
   VERSION = File.read File.expand_path('../../../.version', __FILE__).chomp
@@ -17,39 +17,45 @@ module Lux
   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(:live?)    { LUX_LIVE }    # is on a live web server
-  define_method(:verbose?) { LUX_VERBOSE } # show verbose output
-  define_method(:cli?)     { $0 == 'pry' || $0.index('/run.rb') || ENV['RACK_ENV'] == 'test' }
+  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 }
+
+  # main rack response
+  def call  env=nil
+    req = Lux::Current.new env
+    req.response.render
+  rescue
+    raise $! if Lux.config(:show_server_errors)
+
+    [500, {}, ['Lux server error']]
+  end
 
-  def env(key=nil)
+  def env key=nil
     return ENV['RACK_ENV'] unless key
     die "ENV['#{key}'] not found" if ENV[key].nil?
     ENV[key]
   end
 
-  def config(key=nil)
+  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]
   end
 
-  def thread
-    Thread.current[:lux]
+  def current
+    Thread.current[:lux][:page] ||= Lux::Current.new('/mock')
   end
 
-  def page
-    Thread.current[:lux][:page] ||= Lux::Page.prepare('/mock')
-  end
-
-  def page=(what)
+  def current=(what)
     Thread.current[:lux][:page] = what
   end
 
-  def cache
-    Lux::Cache
+  def app &block
+    block ? Lux::Application.class_eval(&block) : Lux::Application
   end
 
   def root
@@ -61,7 +67,7 @@ module Lux
   end
 
   def error data
-    page.status 500
+    current.response.status 500
     Lux::Error.show(data)
   end
 
@@ -70,13 +76,9 @@ module Lux
     puts what
   end
 
-  def uid
-    Thread.current[:uid_cnt] ||= 0
-    "uid-#{Thread.current[:uid_cnt]+=1}"
-  end
-
   def on name, ref=nil, &proc
     EVENTS[name] ||= []
+
     if block_given?
       puts "* event: #{name} defined".white
       EVENTS[name].push(proc)
@@ -102,15 +104,23 @@ module Lux
   end
 
   def speed loops=1
-    render_start = Time.now.to_f
+    render_start = Time.monotonic
     loops.times { yield }
-    num = ((Time.now.to_f - render_start)*1_000_000).to_i.to_s
-    num = "#{num} ms"
+    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}"
   end
 
-  def consumed_memory
-    `ps -o rss -p #{$$}`.chomp.split("\n").last.to_i / 1000
+  # load specific plugin
+  def plugin name
+    dir  = '%s/plugins/%s' % [Lux.fw_root, name]
+    base = '%s/base.rb' % dir
+
+    if File.exist?(base)
+      load base
+    else
+      Lux::Config.require_all('%s/*' % dir)
+    end
   end
 end
 

data/lib/lux/mailer/mailer.rb

@@ -11,63 +11,80 @@
 # Mailer.confirm_email('rejotl@gmailcom').body
 
 class Lux::Mailer
+  ClassCallbacks.define self, :before, :after
+  class_attribute :helper
 
-  BeforeAndAfter.define self, :before, :after
+  attr_reader :mail
 
-  attr_reader :subject, :to, :from
+  class << self
+    # Mailer.prepare(:confirm_email, 'rejotl@gmailcom')
+    def prepare template, *args
+      obj = new
+      obj.instance_variable_set :@_template, template
 
-  # Mailer.prepare(:confirm_email, 'rejotl@gmailcom')
-  def self.prepare(template, *args)
-    obj = new
-    obj.instance_variable_set :@_template, template
+      ClassCallbacks.execute obj, :before
+      obj.send template, *args
+      ClassCallbacks.execute obj, :after
 
-    BeforeAndAfter.execute(obj, :before)
-    obj.send(template, *args)
-    BeforeAndAfter.execute(obj, :after)
+      obj
+    end
 
-    obj
+    def render method_name, *args
+      send(method_name, *args).body
+    end
+
+    def method_missing method_sym, *args
+      prepare(method_sym, *args)
+    end
+
+    def deliver
+      send(method_name, *args).deliver
+    end
   end
 
-  def self.render(method_name, *args)
-    send(method_name, *args).body
+  ###
+
+  def initialize
+    @mail = DynamicClass.new subject: nil, body: nil, to: nil, cc: nil, from: nil
   end
 
   def deliver
-    raise "From in mailer not defined" unless @from
-    raise "To in mailer not defined" unless @to
-    raise "Subject in mailer not defined" unless @subject
+    raise "From in mailer not defined"    unless @mail.from
+    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]         = @from
-    m[:to]           = @to
-    m[:subject]      = @subject
-    m[:body]         = body
+    m[:from]         = @mail.from
+    m[:to]           = @mail.to
+    m[:subject]      = @mail.subject
+    m[:body]         = @mail.body || body
     m[:content_type] = 'text/html; charset=UTF-8'
-    m.deliver!
-  end
 
-  def deliver_later
-     Lux.delay(self, :deliver)
+    Thread.new { m.deliver! }
   end
 
-  def self.deliver
-    send(method_name, *args).deliver
+  def deliver_later
+     Lux.delay self, :deliver
   end
 
   def body
-    Lux::Template.render_with_layout("mailer/#{@_template}", instance_variables_hash)
+    return @mail.body if @mail.body
+
+    helper = Lux::Helper.new self, self.class.helper
+
+    Lux::Template.render_with_layout "mailer/#{@_template}", helper
   end
 
   def subject
-    @subject
+    @mail.subject
   end
 
-  def self.method_missing(method_sym, *args)
-    prepare(method_sym, *args)
+  def to
+    @mail.to
   end
 
 end

data/lib/lux/{page → response}/lib/flash.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-class Lux::Page::Flash
+class Lux::Response::Flash
 
   # flash.info 'messsage ...'
   # flash.info = 'messsage ...'

data/lib/lux/response/lib/header.rb

@@ -0,0 +1,21 @@
+
+class Lux::Response::Header
+  attr_reader :data
+
+  def initialize
+    @data = {}
+  end
+
+  def [] key
+    @data[key.downcase]
+  end
+
+  def []= key, value
+    @data[key.downcase] = value
+  end
+
+  def to_h
+    @data.to_h.sort.to_h
+  end
+
+end

data/lib/lux/response/response.rb

@@ -0,0 +1,237 @@
+# response.header 'x-blah', 123
+# response.max_age = 10
+# response.public  = true
+# response.status  = 500
+class Lux::Response
+  # define in seconds, how long should page be accessible in client cache
+  # if defined, cache becomes public and can be cache by proxies
+  # use with care.only for static resources and
+  attr_reader :max_age
+
+  attr_accessor :body, :headers, :cookies, :content_type, :status, :cookie_multidomain, :cookie_domain
+
+  def initialize
+    @render_start = Time.monotonic
+    @headers      = Lux::Response::Header.new
+    @max_age      = 0
+  end
+
+  def current
+    Lux.current
+  end
+
+  def header name, value=:_
+    @headers[name] = value if value != :_
+    @headers[name]
+  end
+
+  def max_age= age
+    @max_age = age.to_i
+  end
+
+  def etag *args
+    unless @headers['etag']
+      args.push current.request.url
+
+      key = '"%s"' % Lux.cache.generate_key(args)
+      key = 'W/%s' % key unless max_age > 0
+
+      @headers['etag'] = key
+    end
+
+    if current.request.env['HTTP_IF_NONE_MATCH'] == @headers['etag']
+      @status = 304
+      @body   = 'not-modified'
+      true
+    else
+      false
+    end
+  end
+
+  def status num=nil
+    return @status unless num
+    raise 'Bad status value [%s]' % num unless num.is_numeric?
+
+    @status ||= num
+    @status
+  end
+  alias :status= :status
+
+  def halt status=nil, msg=nil
+    @status = status || 400
+    @body   = msg if msg
+
+    throw :done
+  end
+
+  def body what=nil
+    @body ||= what
+
+    if @body && block_given?
+      @body = yield @body
+      Lux.error 'Lux.current.response.body is not a string (bad current.response.body filter)' unless @body.is_a?(String)
+    end
+
+    @body
+  end
+  alias :body= :body
+
+  def body! what
+    @body = what
+  end
+
+  def content_type type=nil
+    return @content_type unless type
+
+    # can be set only once
+    return @content_type if @content_type
+
+    type = 'application/json' if type == :json
+    type = 'text/plain' if type == :text
+    type = 'text/html' if type == :html
+
+    raise 'Invalid page content-type %s' % type if type === Symbol
+
+    @content_type = type
+  end
+
+  def content_type= type
+    content_type type
+  end
+
+  def flash message=nil
+    @flash ||= Flash.new current.session[:lux_flash]
+
+    message ? @flash.error(message) : @flash
+  end
+
+  def redirect where=nil, opts={}
+    return @headers['location'] unless where
+
+    @status = opts.delete(:status) || 302
+    opts.map { |k,v| flash.send(k, v) }
+
+    @headers['location']   = where.index('//') ? where : "#{current.host}#{where}"
+    @headers['access-control-expose-headers'] ||= 'Location'
+
+    @body = %[redirecting to #{@headers['location']}\n\n#{opts.values.join("\n")}]
+
+    throw :done
+  end
+
+  def permanent_redirect where
+    redirect where, status:301
+  end
+
+  # auth { |user, pass| [user, pass] == ['foo', 'bar'] }
+  def auth relam=nil
+    if auth = current.request.env['HTTP_AUTHORIZATION']
+      credentials = auth.to_s.split('Basic ', 2)[1].unpack("m*").first.split(':', 2)
+      return true if yield *credentials
+    end
+
+    status 401
+    header('WWW-Authenticate', 'Basic realm="%s"' % relam.or('default'))
+    body = ErrorCell.unauthorized('HTTP 401 Authorization needed')
+
+    false
+  end
+
+  def write_response_body
+    unless @body
+      @status = 404
+      @body = Lux.error 'Document not found'
+    end
+
+    # respond as JSON if we recive hash
+    if @body.kind_of?(Hash)
+      @body = Lux.dev? ? JSON.pretty_generate(@body) : JSON.generate(@body)
+
+      if current.request.params[:callback]
+        @body = "#{current.request.params[:callback]}(#{ret})"
+        @content_type ||= 'text/javascript'
+      else
+        @content_type ||= 'application/json'
+      end
+
+      @body += "\n"
+    else
+      # if somebody sets @content_type, respect that
+      @body = @body.to_s unless @body.kind_of?(String)
+      @content_type ||= 'text/plain' if @body[0,1] != '<'
+      @content_type ||= 'text/html'
+    end
+  end
+
+  def write_response_header
+    domain =
+      if cookie_domain
+        cookie_domain
+      elsif cookie_multidomain && current.domain.index('.')
+        ".#{current.domain}"
+      else
+        current.request.host
+      end
+
+    # cache-control
+    @headers['cache-control'] ||= Proc.new do
+      cc      = ['max-age=%d' % max_age]
+
+      if max_age > 0
+        cc.push 'public, no-cache'
+      else
+        cc.push 'private, must-revalidate'
+      end
+
+      cc.join(', ')
+    end.call
+
+    current.session[:lux_flash] = flash.to_h
+
+    # dont annd cookies to public pages (images, etc..)
+    add_cookies = true
+    add_cookies = false if @headers['cache-control'].index('public')
+
+    if add_cookies
+      encrypted = Crypt.encrypt(current.session.to_json)
+
+      if current.cookies[Lux.config.session_cookie_name] != encrypted
+        @headers['set-cookie']  = "#{Lux.config.session_cookie_name}=#{encrypted}; Expires=#{(Time.now+1.month).utc}; Path=/; Domain=#{domain};"
+      end
+    end
+
+    etag(@body) if current.request.request_method == 'GET'
+
+    @headers['x-lux-speed']     = "#{((Time.monotonic - @render_start)*1000).round(1)} ms"
+    @headers['content-type']  ||= "#{@content_type}; charset=utf-8"
+    @headers['content-length']  = @body.bytesize
+    # if "no-store" is present then HTTP_IF_NONE_MATCH is not sent from browser
+  end
+
+  def write_response
+    write_response_body
+    write_response_header
+
+    @status ||= 200
+    Lux.log " #{@status}, #{@headers['x-lux-speed']}"
+
+    if ENV['LUX_PRINT_ROUTES']
+      print '* Finished route print '
+      puts @status == 404 ? 'without a match'.red : 'with a match'.green
+      exit
+    end
+
+    [@status, @headers.to_h, [@body]]
+  end
+
+  def render
+    Lux.log "\n#{current.request.request_method.white} #{Lux.current.request.path.white}"
+
+    Lux::Config.live_require_check! if Lux.config(:auto_code_reload)
+
+    Lux::Application.new.main
+
+    write_response
+  end
+
+end