lux-fw 0.5.36 → 0.6.2

data/lib/lux/lux.rb

@@ -1,165 +1,108 @@
-# frozen_string_literal: true
-
-require_relative '../common/class_callbacks'
-require_relative 'cache/cache'
-
 module ::Lux
   extend self
 
-  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(: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 }
+  VERSION ||= File.read File.expand_path('../../../.version', __FILE__).chomp
+
+  def root
+    @lux_app_root ||= Pathname.new(ENV.fetch('APP_ROOT') { Dir.pwd }).freeze
+  end
+
+  def fw_root
+    @lux_fw_root ||= Pathname.new(File.expand_path('../../', File.dirname(__FILE__))).freeze
+  end
 
   # main rack response
-  def call env=nil
-    state  = Lux::Current.new env
-    app    = Lux::Application.new state
-    app.render
-  rescue => error
-    if Lux.config(:dump_errors)
-      raise error
-    else
-      log error.backtrace
-      [500, {}, ['Server error: %s' % error.message]]
+  def call env = nil
+    Timeout::timeout Lux::Config.app_timeout do
+      app  = Lux::Application.new env
+      app.render_base || raise('No RACK response given')
     end
-  end
+  rescue => err
+    Lux::Error.log err
 
-  def env key=nil
-    if key
-      value = ENV[key]
-      die "ENV['#{key}'] not found" if value.nil?
-      value
+    if Lux.env.show_errors?
+      raise err
     else
-      ENV['RACK_ENV']
+      [500, {}, ['Server error: %s' % err.message]]
     end
   end
 
-  def config key=nil
-    if key
-      value = CONFIG[key]
-      die 'Lux.config.%s not found' % key if value.nil?
-      value.kind_of?(Proc) ? value.call() : value
+  # simple block to calc block execution speed
+  def speed
+    render_start = Time.monotonic
+    yield
+    num = (Time.monotonic - render_start) * 1000
+    if num > 1000
+      '%s sec' % (num/1000).round(2)
     else
-      CONFIG
+      '%s ms' % num.round(1)
     end
   end
 
-  def current
-    Thread.current[:lux][:page] ||= Lux::Current.new('/mock')
-  end
-
-  def current=(what)
-    Thread.current[:lux][:page] = what
+  def info text
+    if text.class == Array
+      text.each {|line| self.info line }
+    else
+      puts '* %s' % text.magenta
+    end
   end
 
-  def app &block
-    block ? Lux::Application.class_eval(&block) : Lux::Application
+  # Cdn.run has maybe better runner, inspect
+  def run command, get_result = false
+    puts command.light_black
+    logger(:system_run).info command
+    get_result ? `${command}` : system(command)
   end
 
-  def error data=nil
-    data ? Lux::Error.render(data) : Lux::Error
+  def die text
+    puts "Lux FATAL: #{text}".red
+    logger(:system_die).error text
+    exit
   end
 
-  # simple log to stdout
-  def log what=nil
-    return unless Lux.config(:log_to_stdout)
-    puts what || yield
+  def app_caller
+    app_line   = caller.find { |line| !line.include?('/lux-') && !line.include?('/.') && !line.include?('(eval)') }
+    app_line ? app_line.split(':in ').first.sub(Lux.root.to_s, '.') : nil
   end
 
-  # simple interface to plugins
-  # Lux.plugin :foo
-  # Lux.plugin
-  def plugin *args
-    args.first ? Lux::Config::Plugin.load(*args) : Lux::Config::Plugin
-  end
+  def delay time_to_live = nil
+    Thread.new do
+      time_to_live ||= Lux.config.delay_timeout
 
-  # 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, &block
-    if block_given?
-      puts 'add'
-
-      t = Thread.new do
-        begin
-          block.call
-        rescue => e
-          Lux.logger(:delay_errors).error [e.message, e.backtrace]
-        end
+      unless time_to_live.is_a?(Numeric)
+        raise 'Time to live is not integer (seconds)'
       end
 
-      BACKGROUND_THREADS.push t
-    elsif args[0]
-      # Lux.delay(mail_object, :deliver)
-      Lux::DelayedJob.push(*args)
-    else
-      Lux::DelayedJob
+      Timeout::timeout time_to_live do
+        yield
+      end
     end
   end
+end
 
-  # 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!
+def Lux
+  if self.class == Rack::Builder
+    $rack_handler = self
+    run Lux
+    puts Lux::Config.start_info
+  else
+    raise 'Lux error: Rack not found'
   end
+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
-    yield
-    num = (Time.monotonic - render_start) * 1000
-    '%s ms' % num.round(1)
-  end
+require_relative 'environment/environment'
+require_relative 'environment/lux_adapter'
 
-  # Lux.logger(:foo).warn 'bar'
-  def logger name=nil
-    name ||= ENV.fetch('RACK_ENV').downcase
+require_relative 'config/config'
+require_relative 'config/lux_adapter'
 
-    MCACHE['lux-logger-%s' % name] ||=
-    Logger.new('./log/%s.log' % name).tap do |it|
-      it.formatter = Lux.config.logger_formater
-    end
-  end
+if $lux_start_time
+  # for better start stats add $lux_start_time ||= Time.now to begginging of Gemfile
+  $lux_start_time = [$lux_start_time, Time.now]
+else
+  $lux_start_time = Time.now
 end
-
-require_relative 'config/config'

data/lib/lux/mailer/README.md

@@ -1,4 +1,6 @@
-## Lux::Mailer - send mails
+## Lux::Mailer
+
+Light wrapper arrond [ruby mailer gem](https://github.com/mikel/mail).
 
 * before and after class methods are supported
   * before is called mail rendering started
@@ -16,7 +18,7 @@
   * execute after filter
   * deliver the mail
 
-### Example
+#### Example
 
 sugessted usage
 
@@ -39,13 +41,17 @@ Mailer.email_login('foo@bar.baz').deliver
 Mailer.email_login('foo@bar.baz').body
 ```
 
-### Example code
+#### Code
 
 ```ruby
 class Mailer < Lux::Mailer
   helper :mailer
 
-  # before mail is sent
+  # before method call
+  before do
+  end
+
+  # after method call, but before mail is sent
   after do
     mail.from = "#{App.name} <no-reply@#{Lux.config.host}>"
   end
@@ -67,7 +73,8 @@ class Mailer < Lux::Mailer
     mail.subject = "#{App.name} – potvrda registracije"
     mail.to      = email
 
-    @link    = "#{App.http_host}/profile/password?user_hash=#{Crypt.encrypt(email)}"
+    # instance variables will be pased to templaes
+    @link = "#{App.http_host}/profile/password?user_hash=#{Crypt.encrypt(email)}"
   end
 end
 ```

data/lib/lux/mailer/lux_config.rb

@@ -0,0 +1,4 @@
+# Default mail logging
+Lux.config.on_mail_send do |mail|
+  Lux.logger(:email).info "[#{self.class}.#{@_template} to #{mail.to}] #{mail.subject}"
+end

data/lib/lux/mailer/mailer.rb

@@ -10,79 +10,101 @@
 # Mailer.email_login('foo@bar.baz').deliver
 # Mailer.email_login('foo@bar.baz').body
 
-class Lux::Mailer
-  class_callback :before
-  class_callback :after
-
-  class_attribute :helper
-  class_attribute :layout, 'mailer'
-
-  attr_reader :mail
-
-  class << self
-    # Mailer.prepare(:email_login, 'foo@bar.baz')
-    def prepare template, *args
-      obj = new
-      obj.instance_variable_set :@_template, template
-      Object.class_callback :before, obj
-      obj.send template, *args
-      Object.class_callback :after, obj
-      obj
+# if you want to cancel mail delivery - mail.to = false
+module Lux
+  class Mailer
+    include ClassCallbacks
+
+    cattr :template_root, default: './app/views', class: true
+    cattr :helper, class: true
+    cattr :layout, default: 'mailer', class: true
+
+    define_callback :before
+    define_callback :after
+
+    attr_reader :mail
+
+    class << self
+      # Mailer.prepare(:email_login, 'foo@bar.baz')
+      def prepare template, *args
+        obj = new
+        obj.instance_variable_set :@_template, template
+        obj.run_callback :before
+
+        if args[0].class == Hash
+          obj.send template, **args[0]
+        else
+          obj.send template, *args
+        end
+
+        obj.run_callback :after
+        obj
+      end
+
+      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 render method_name, *args
-      send(method_name, *args).body
-    end
+    ###
 
-    def method_missing method_sym, *args
-      prepare(method_sym, *args)
+    def initialize
+      @mail = {}.to_hwia :subject, :body, :to, :cc, :from
     end
 
-    def deliver
-      send(method_name, *args).deliver
-    end
-  end
+    def body
+      data = @mail.body
 
-  ###
+      unless data
+        helper = Lux::Template::Helper.new self, self.class.helper
+        layout = Lux::Template.find_layout './app/views', self.class.layout
+        data = Lux::Template.render helper, template: "#{cattr.template_root}/mailer/#{@_template}", layout: layout
+      end
 
-  def initialize
-    @mail = FreeStruct.new subject: nil, body: nil, to: nil, cc: nil, from: nil
-  end
+      data.gsub(%r{\shref=(['"])/}) { %[ href=#{$1}#{Lux.config.host}/] }
+    end
 
-  def deliver
-    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
+    def subject
+      @mail.subject
+    end
 
-    m = Mail.new
-    m[:from]         = @mail.from
-    m[:to]           = @mail.to
-    m[:subject]      = @mail.subject
-    m[:body]         = body
-    m[:content_type] = 'text/html; charset=UTF-8'
+    def to
+      @mail.to
+    end
 
-    Lux.delay { m.deliver! }
+    def deliver
+      if m = build_mail_object
+        Lux.current.delay(m) { |mail| mail.deliver! }
+      end
+    end
 
-    instance_exec m, &Lux.config.on_mail
-  end
+    private
 
-  def body
-    data = @mail.body
+    def build_mail_object
+      return if @mail.to.class == FalseClass
 
-    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
+      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
 
-    data.gsub(%r{\shref=(['"])/}) { %[ href=#{$1}#{Lux.config.host}/] }
-  end
+      m = Mail.new
+      m[:from]         = @mail.from
+      m[:to]           = @mail.to
+      m[:subject]      = @mail.subject
+      m[:body]         = body
+      m[:content_type] = 'text/html; charset=UTF-8'
 
-  def subject
-    @mail.subject
-  end
+      instance_exec m, &Lux.config.on_mail_send
 
-  def to
-    @mail.to
+      m
+    end
   end
-
-end
+end

data/lib/lux/plugin/README.md

@@ -0,0 +1,19 @@
+## Lux.plugin (Lux::Plugin)
+
+Plugin management
+
+* loads plugins in selected namespace, default namespace :main
+* gets plugins in selected namespace
+
+```ruby
+# load a plugin
+Lux.plugin name_or_folder
+Lux.plugin name: :foo, folder: '/.../...', namespace: [:main, :admin]
+Lux.plugin name: :bar
+
+# plugin folder path
+Lux.plugin.folder(:foo) # /home/app/...
+
+# Load lux plugin
+Lux.plugin :db
+```

data/lib/lux/plugin/lux_adapter.rb

@@ -0,0 +1,8 @@
+module Lux
+  # simple interface to plugins
+  # Lux.plugin :foo
+  # Lux.plugin
+  def plugin *args
+    args.first ? ::Lux::Plugin.load(*args) : ::Lux::Plugin
+  end
+end

data/lib/lux/plugin/plugin.rb

@@ -0,0 +1,65 @@
+module Lux
+  module Plugin
+    extend self
+
+    PLUGIN = {}
+
+    # load specific plugin
+    # Lux.plugin :foo
+    # Lux.plugin 'foo/bar'
+    # Lux.plugin.folders
+    # Lux.plugin(:api).folder
+    def load arg
+      arg = arg.to_s if arg.is_a?(Symbol)
+
+      if arg.is_a?(String)
+        arg = arg.include?('/') ? { folder: arg } : { name: arg }
+      end
+
+      opts           = arg.to_hwia :name, :folder, :namespace
+      opts.name    ||= opts.folder.split('/').last
+      opts.name      = opts.name.to_s
+      opts.folder  ||= Lux.fw_root.join('plugins', opts.name).to_s
+      opts.namespace = [opts.namespace] unless opts.namespace.is_a?(Array)
+
+      return PLUGIN[opts.name] if PLUGIN[opts.name]
+
+      die(%{Plugin "#{opts.name}" not found in "#{opts.folder}"}) unless Dir.exist?(opts.folder)
+
+      PLUGIN[opts.name] ||= opts
+
+      base = Pathname.new(opts.folder).join(opts.name, '.rb')
+
+      if base.exist?
+        require base.to_s
+      else
+        Dir.require_all(opts.folder)
+      end
+
+      PLUGIN[opts.name]
+    end
+
+    def get name
+      PLUGIN[name.to_s] || die('Plugin "%s" not loaded' % name)
+    end
+
+    def loaded
+       PLUGIN.values
+    end
+
+    def keys
+      PLUGIN.keys
+    end
+
+    def plugins
+      PLUGIN
+    end
+
+    # get all folders in a namespace
+    def folders namespace=:main
+      list = PLUGIN.values
+      list.select { |it| it.namespace.include?(namespace) }
+      list.map { |it| it.folder }
+    end
+  end
+end

data/lib/lux/render/README.md

@@ -0,0 +1,100 @@
+## Lux.render
+
+Render full pages and templates.
+
+### Render full pages
+
+As a first argument to any render method you can provide
+full [Rack environment](https://www.rubydoc.info/gems/rack/Rack/Request/Env).
+
+If you provide only local path,
+[`Rack::MockRequest`](https://www.rubydoc.info/gems/rack/Rack/MockRequest) will be created.
+
+Two ways of creating render pages are provided.
+
+* full builder `Lux.render(@path, @full_opts)`
+* helper builder with request method as method name `Lux.render.post(@path, @params_hash, @rest_of_opts)`
+
+```ruby
+# render options - all optional
+opts = {
+  query_string: {}
+  post: {},
+  body: String
+  request_method: String
+  session: {}
+  cookies: {}
+}
+
+# when passing data directly, renders full page with all options
+page = Lux.render('/about', opts)
+
+# you can use request method prefix
+page = Lux.render.post('/api/v1/orgs/list', { page_size: 100 }, rest_of_opts)
+page = Lux.render.get('/search', { q: 'london' }, { session: {user_id: 1} })
+
+page.info # gets info hash + body
+# {
+#   body:    '{}',
+#   time:    '5ms',
+#   status:  200,
+#   session: { user_id: 123 }
+#   headers: { ... }
+# }
+
+page.render # get only body
+```
+
+
+### Render templates
+
+Renders templates, wrapper arround [ruby tilt gem](https://github.com/rtomayko/tilt).
+
+```ruby
+Lux.render.template(@scope, @template)
+Lux.render.template(@scope, template: @template, layout: @layout_file)
+Lux.render.template(@scope, @layout_template) { @yield_data }
+```
+
+Scope is any object in which context tmplate will be rendered.
+
+* you can pass `self` so template has access to the same instance
+  variables and methods as current scope.
+* you can construct full valid helper with `Lux.template.helper(@scope, :foo, :bar)`.
+  New helper class will be created from `FooHelper module and BarHelper module`,
+  and it will be populated with `@scope` instance variables.
+
+```ruby
+  # HtmlHelper module or CustomModule has to define link_to method
+  helper = Lux.template.helper(@instance_variables_hash, :html, :custom, ...)
+  helper.link_to('foo', '#bar') # <a href="#bar">foo</a>
+```
+
+Tip: If you want to access helper mehods while in controller, just use `helper`.
+
+
+### Render controllers - [Lux::Controller](https://github.com/dux/lux-fw/tree/master/lib/lux/controller)
+
+Render controller action without routes, pass a block to yield before action call
+if you need to set up params or instance variables.
+
+```ruby
+Lux.render.controller('main/cities#foo').body
+Lux.render.controller('main/cities#bar') { @city = City.last_updated }.body
+```
+
+### Render cells - [Lux::ViewCells](https://github.com/dux/lux-fw/tree/master/lib/lux/view_cell)
+
+Convenience helper is available to render cells, but preffered way is to call cell directly.
+
+```ruby
+# UserCell.new.in_a_box @user
+Lux.render.cell(:user).in_a_box @user
+
+# UserCell.new(self).in_a_box
+Lux.render.cell(:user, self).in_a_box
+
+# UserCell.new(self, user: @user).in_a_box
+Lux.render.cell(:user, user: @user).in_a_box
+````
+

data/lib/lux/render/render.rb

@@ -0,0 +1,12 @@
+module Lux
+  # Lux.app.new(path, full_opts).info
+  # Lux.render.post(path, params, rest_of_opts).info
+  # Lux.render.get('/search', { q: 'london' }, { session: {user_id: 1} }).info  def render *args
+  def render *args
+    if args.first
+      app.new(*args)
+    else
+      app::Render
+    end
+  end
+end