lux-fw 0.2.3 → 0.5.32

data/lib/lux/cache/cache.rb

@@ -1,89 +1,114 @@
 # frozen_string_literal: true
 
-module Lux::Cache
-  extend self
+module Lux
+  class Cache
+    def initialize
+      @server = Lux::Cache::MemoryCache.new
+    end
 
-  # Lux::Cache.sever = :ram
-  def server= obj
-    obj = "Lux::Cache::#{obj.to_s.classify}Cache".constantize if obj.class == Symbol
-    @@server = obj
-  end
+    # sert cache server
+    # Lux.cache.server = :memory
+    # Lux.cache.server = :memcached
+    # Lux.cache.server = Dalli::Client.new('localhost:11211', { :namespace=>Digest::MD5.hexdigest(__FILE__)[0,4], :compress => true,  :expires_in => 1.hour })
+    def server= name
+      @server = if name.is_a?(Symbol)
+        if name == :memcached
+          require 'dalli'
+          Dalli::Client.new('127.0.0.1:11211', { :namespace=>Digest::MD5.hexdigest(__FILE__)[0,4], :compress => true,  :expires_in => 1.hour })
+        else
+          "Lux::Cache::#{name.to_s.classify}Cache".constantize.new
+        end
+      else
+        name
+      end
 
-  def read key
-    return nil if (Lux.current.no_cache? rescue false)
-    @@server.get(key)
-  end
-  alias :get :read
+      fetch('cache-test') { true }
+    end
 
-  def read_multi *args
-    @@server.get_multi(*args)
-  end
-  alias :get_multi :read_multi
+    def server
+      @server
+    end
 
-  def write key, data, ttl=nil
-    ttl = ttl.to_i if ttl
-    @@server.set(key, data, ttl)
-  end
-  alias :set :write
+    def read key
+      return nil if (Lux.current.no_cache? rescue false)
+      @server.get(key)
+    end
+    alias :get :read
 
-  def delete key, data=nil
-    @@server.delete(key)
-  end
+    def read_multi *args
+      @server.get_multi(*args)
+    end
+    alias :get_multi :read_multi
+
+    def write key, data, ttl=nil
+      ttl = ttl.to_i if ttl
+      @server.set(key, data, ttl)
+    end
+    alias :set :write
+
+    def delete key, data=nil
+      @server.delete(key)
+    end
 
-  def fetch key, opts={}
-    opts     = { ttl: opts } unless opts.is_a?(Hash)
-    opts     = opts.to_opts!(:ttl, :force, :log)
+    def fetch key, opts={}
+      opts = { ttl: opts } unless opts.is_a?(Hash)
+      opts = opts.to_opts(:ttl, :force, :log, :if)
 
-    opts.ttl     = opts.ttl.to_i if opts.ttl
-    opts.log   ||= Lux.config(:log_to_stdout) unless opts.log.class == FalseClass
-    opts.force ||= Lux.current.try(:no_cache?)   unless opts.force.class == FalseClass
+      return yield if opts.if.is_a?(FalseClass)
 
-    @@server.delete key if opts.force
+      opts.ttl     = opts.ttl.to_i if opts.ttl
+      opts.log   ||= Lux.config(:log_to_stdout)  unless opts.log.class   == FalseClass
+      opts.force ||= Lux.current.try(:no_cache?) unless opts.force.class == FalseClass
 
-    Lux.log " Cache.fetch.get #{key} (ttl: #{opts.ttl.or(:nil)})".green if opts.log
+      @server.delete key if opts.force
 
-    data = @@server.fetch key, opts.ttl do
-      speed = Lux.speed { data = yield }
+      Lux.log " Cache.fetch.get #{key} (ttl: #{opts.ttl.or(:nil)})".green if opts.log
 
-      Lux.log " Cache.fetch.SET #{key} len:#{data.to_s.length} (#{speed})".red if opts.log
+      data = @server.fetch key, opts.ttl do
+        speed = Lux.speed { data = yield }
+
+        Lux.log " Cache.fetch.SET #{key} len:#{data.to_s.length} (#{speed})".red if opts.log
+
+        data
+      end
 
       data
     end
 
-    data
-  end
-
-  def is_available?
-    set('lux-test', 9)
-    get('lux-test') == 9
-  end
+    def is_available?
+      set('lux-test', 9)
+      get('lux-test') == 9
+    end
 
-  def generate_key *data
-    keys = []
+    def generate_key *data
+      keys = []
 
-    for el in [data].flatten
-      keys.push el.id if el.respond_to?(:id)
+      for el in [data].flatten
+        keys.push el.id if el.respond_to?(:id)
 
-      if el.respond_to?(:updated_at)
-        keys.push el.updated_at
-      elsif el.respond_to?(:created_at)
-        keys.push el.created_at
-      else
-        keys.push el.to_s
+        if el.respond_to?(:updated_at)
+          keys.push el.updated_at
+        elsif el.respond_to?(:created_at)
+          keys.push el.created_at
+        else
+          keys.push el.to_s
+        end
       end
+
+      key = keys.join('-')
+      Crypt.sha1(key)
     end
 
-    key = keys.join('-')
-    Crypt.sha1(key)
-  end
+    def []= key, value
+      @server.set key.to_s, value
+      value
+    end
 
-  def []= key, value
-    @@server.set key.to_s, value
-    value
-  end
+    def [] key
+      @server.get key.to_s
+    end
 
-  def [] key
-    @@server.get key.to_s
   end
-
 end
+
+require_relative 'lib/memory'

data/lib/lux/cache/lib/{ram.rb → memory.rb}

@@ -1,18 +1,16 @@
-module Lux::Cache::RamCache
-  extend self
-
+class Lux::Cache::MemoryCache
   @@lock = Mutex.new
   @@ram_cache = {}
   @@ttl_cache = {}
 
-  def set(key, data, ttl=nil)
+  def set key, data, ttl=nil
     @@lock.synchronize do
       @@ttl_cache[key] = Time.now.to_i + ttl if ttl
       @@ram_cache[key] = data
     end
   end
 
-  def get(key)
+  def get key
     if ttl_check = @@ttl_cache[key]
       return nil if ttl_check < Time.now.to_i
     end
@@ -20,13 +18,13 @@ module Lux::Cache::RamCache
     @@ram_cache[key]
   end
 
-  def fetch(key, ttl=nil)
+  def fetch key, ttl=nil
     data = get key
     return data if data
     set(key, yield, ttl)
   end
 
-  def delete(key)
+  def delete key
     @@lock.synchronize do
       @@ram_cache.delete(key)
     end

data/lib/lux/cache/lib/null.rb

@@ -1,23 +1,21 @@
-module Lux::Cache::NullCache
-  extend self
-
-  def set(key, data, ttl=nil)
+class Lux::Cache::NullCache
+  def set key, data, ttl=nil
     data
   end
 
-  def get(key)
+  def get key
     nil
   end
 
-  def fetch(key, ttl=nil)
+  def fetch key, ttl=nil
     yield
   end
 
-  def delete(key)
+  def delete key
     nil
   end
 
-  def get_multi(*args)
+  def get_multi *args
     {}
   end
 end

data/lib/lux/config/config.rb

@@ -2,23 +2,18 @@
 
 # $LOADED_FEATURES.select{ |f| f.index('/app/') || f.index('/lux/') }
 
+require 'yaml'
+
 module Lux::Config
   extend self
 
-  LIVE_RELOAD ||= {}
-
-  # if we have errors in module loading, try to load them one more time
-  @module_error = []
-
   # requires all files recrusive in, with spart sort
-  def require_all files
-    files = files.to_s
-    files += '/*' unless files.include?('*')
-
-    file_errors = []
-    glob = `echo #{files} #{files}/* #{files}/*/*  #{files}/*/*/* #{files}/*/*/*/* |tr ' ' '\n' | grep .rb`.split("\n")
+  def require_all dir_path
+    dir_path = dir_path.to_s.sub(/\/$/,'')
+    raise '* is not allowed' if dir_path.include?('*')
 
-    glob.select{ |o| o.index('.rb') }.map{ |o| o.split('.rb')[0]}.each do |ruby_file|
+    glob = `echo #{dir_path}/* #{dir_path}/*/*  #{dir_path}/*/*/* #{dir_path}/*/*/*/* #{dir_path}/*/*/*/*/* #{dir_path}/*/*/*/*/*/* |tr ' ' '\n' | grep .rb`.split("\n")
+    glob.select{ |o| o.index('.rb') }.each do |ruby_file|
       require ruby_file
     end
   end
@@ -31,42 +26,39 @@ module Lux::Config
     end
   end
 
-  # check all files and reload if needed
   def live_require_check!
-    if LIVE_RELOAD.blank?
-      root = Lux.root.to_s
-      for file in $LOADED_FEATURES.select{ |f| f.index(root) || f.index('/lux/') }
-        LIVE_RELOAD[file] = File.mtime(file).to_i
-      end
-    end
+    $live_require_check ||= Time.now
 
-    for file, mtime in LIVE_RELOAD
-      new_file_mtime = File.mtime(file).to_i
+    changed_files = $LOADED_FEATURES
+      .select{ |f| f.include?('/app/') || f.include?('lux') }
+      .select {|f| File.mtime(f) > $live_require_check }
 
-      next if mtime == new_file_mtime
-      LIVE_RELOAD[file] = new_file_mtime
-      Lux.log " Reloaded: .#{file.split(Lux.root.to_s).last.red}"
+    for file in changed_files
+      Lux.log ' Reloaded: %s' % file.split(Lux.root.to_s).last.red
       load file
     end
-    true
+
+    $live_require_check = Time.now
   end
 
   def ram
     `ps -o rss -p #{$$}`.chomp.split("\n").last.to_i / 1000
   end
 
-  def show_load_speed load_start=nil
-    return @@load_info || 'No lux load info' unless load_start
+  def start!
+    Object.class_callback :config, Lux::Application
+    start_info $lux_start_time
+  end
 
-    speed = ((Time.now - load_start)*1000).round.to_s.sub(/(\d)(\d{3})$/,'\1s \2')+'ms'
+  def start_info start=nil
+    return @load_info if @load_info
 
     production_mode = true
-
     production_opts = [
-      [:compile_assets,     false],
-      [:auto_code_reload,   false],
-      [:show_server_errors, false],
-      [:log_to_stdout,      false],
+      [:compile_assets,   false],
+      [:auto_code_reload, false],
+      [:dump_errors,      false],
+      [:log_to_stdout,    false],
     ]
 
     opts = production_opts.map do |key, production_value|
@@ -78,36 +70,101 @@ module Lux::Config
       config_ok ? data : data.yellow
     end
 
-    puts @@load_info = '* Config: %s' % opts.join(', ')
-
-    mode = production_mode ? 'production'.green : 'development'.yellow
-
-    "* #{'Lux'.white} loaded #{mode} mode in #{speed.to_s.white}, uses #{ram.to_s.white} MB RAM with total of #{Gem.loaded_specs.keys.length.to_s.white} gems in spec".tap do |it|
-      @@load_info += "\n#{it}"
+    mode  = production_mode ? 'production'.green : 'development'.yellow
+    speed =
+    if start
+      text = ((Time.now - start)*1000).round.to_s.sub(/(\d)(\d{3})$/,'\1s \2')
+      ' in %s ms' % text.to_s.white
+    else
     end
-  end
 
-  def set_default_vars
-    # how long will session last if BROWSER or IP change
-    Lux.config.session_forced_validity = 5.minutes.to_i
+    info = []
+    info.push '* Config: %s' % opts.join(', ')
+    info.push "* Lux loaded #{mode} mode#{speed}, uses #{ram.to_s.white} MB RAM with total of #{Gem.loaded_specs.keys.length.to_s.white} gems in spec"
+
+    @@load_info = info.join($/)
 
-    # name of the session cookie
-    Lux.config.session_cookie_name = '__luxs'
+    puts @@load_info if start
+  end
 
+  def init!
     # Show server errors to a client
-    Lux.config.show_server_errors = false
+    Lux.config.dump_errors = Lux.dev?
 
     # Log debug output to stdout
-    Lux.config.log_to_stdout = false
+    Lux.config.log_to_stdout = Lux.dev?
 
     # Automatic code reloads in development
-    Lux.config.auto_code_reload   = false
-  end
+    Lux.config.auto_code_reload = Lux.dev?
+
+    # Runtime compile js and css assets
+    Lux.config.compile_assets = Lux.dev?
+
+    Lux.config.session_cookie_domain = false
+    Lux.config.asset_root            = false
 
+    ###
+
+    if ENV['LUX_MODE'].to_s.downcase == 'log'
+      Lux.config.dump_errors      = false
+      Lux.config.auto_code_reload = false
+      Lux.config.compile_assets   = false
+    end
+
+    ###
+
+    # Default error logging
+    Lux.config.error_logger = proc do |error|
+      ap [error.class, error.message, Lux.error.split_backtrace(error)]
+
+      'no-key'
+    end
+
+    # Default mail logging
+    Lux.config.on_mail = proc do |mail|
+      Lux.logger(:email).info "[#{self.class}.#{@_template} to #{mail.to}] #{mail.subject}"
+    end
+
+    # default event bus error handle
+    Lux.config.on_event_bus_error = proc do |error, name|
+      Lux.logger(:event_bus).error '[%s] %s' % [name, error.message]
+    end
+
+    # server static files
+    Lux.config.serve_static_files = true
+
+    # Template to show when displaying unhandled server side errors
+    Lux.config.server_error_template = proc do |text|
+      text = text.to_s.gsub('<', '&lt;')
+      text = text.to_s.gsub($/,'<br />')
+
+      %[<html>
+          <head>
+            <title>Server error (#{Lux.current.response.status})</title>
+          </head>
+          <body style="background:#fff; font-size:12pt; font-family: Arial; padding: 20px;">
+            <h3>HTTP error #{Lux.current.response.status} in #{Lux.config.app.name}</h3>
+            <pre style="color:red; padding:10px; background-color: #eee; border: 1px solid #ccc; font-family:'Lucida console'; line-height: 15pt;">#{text}</pre>
+            <br>
+            <a href="https://httpstatuses.com/#{Lux.current.response.status}" target="http_error">more info on http error</a>
+          </body>
+        </html>]
+    end
+
+    # inflector
+    String.inflections do |inflect|
+      inflect.plural   'bonus', 'bonuses'
+      inflect.plural   'clothing', 'clothes'
+      inflect.plural   'people', 'people'
+      inflect.singular /news$/, 'news'
+    end
+  end
 end
 
-class Object
-  def reload!
-    Lux::Config.live_require_check!
+if Lux.cli?
+  class Object
+    def reload!
+      Lux::Config.live_require_check!
+    end
   end
 end

data/lib/lux/config/lib/plugin.rb

@@ -0,0 +1,65 @@
+module Lux::Config::Plugin
+  extend self
+
+  @plugins = {}
+
+  # load specific plugin
+  # Lux.plugin :foo
+  # Lux.plugin 'foo/bar'
+  # Lux.plugin.folders
+  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_opts name: String, folder: String, namespace: Symbol
+    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 @plugins[opts.name] if @plugins[opts.name]
+
+    die(%{Plugin "#{opts.name}" not found in "#{opts.folder}"}) unless Dir.exist?(opts.folder)
+
+    @plugins[opts.name] ||= opts
+
+    base = Pathname.new(opts.folder).join(opts.name, '.rb')
+
+    if base.exist?
+      require base.to_s
+    else
+      Lux::Config.require_all(opts.folder)
+    end
+
+    @plugins[opts.name]
+  end
+
+  def get name
+    @plugins[name.to_s] || die('Plugin "%s" not loaded' % name)
+  end
+
+  def loaded
+     @plugins.values
+  end
+
+  def keys
+    @plugins.keys
+  end
+
+  def plugins
+    @plugins
+  end
+
+  # get all folders in a namespace
+  def folders namespace=:main
+    name = name.to_sym
+
+    list = @plugins.values
+    list.select { |it| it.namespace.include?(namespace) }
+    list.map { |it| it.folder }
+  end
+
+end

data/lib/lux/config/lib/secrets.rb

@@ -0,0 +1,48 @@
+# if you use encrypted secrets
+# * edit ./tmp/secrets.yaml
+# * increase version by 1
+# * run "rake secrets" to encrypt secrets to ./config/secrets.enc
+
+# if you use unprotected secrets in ./config/secrets.yaml
+# * edit the file, no other actions needed
+
+require 'yaml'
+
+class Lux::Config::Secrets
+  attr_reader :read_file, :secret_file, :secret, :strength
+
+  def initialize
+    @read_file   = Pathname.new './tmp/secrets.yaml'
+    @secret_file = Pathname.new './config/secrets.enc'
+    @common_file = Pathname.new './config/secrets.yaml'
+    @secret      = Lux.config.secret_key_base || Lux.config.secret || ENV['SECRET'] || die('ENV SECRET not found')
+    @strength    = 'HS512'
+  end
+
+  def write
+    encoded = JWT.encode @read_file.read, @secret, @strength
+    @secret_file.write encoded
+  end
+
+  def encoded_data
+    JWT.decode(@secret_file.read, @secret, true, { algorithm: @strength }).first
+  end
+
+  def to_h
+    it = if @common_file.exist?
+      @common_file.read
+    else
+      encoded_data
+    end
+
+    it   = YAML.load it
+    data = it['shared'] || {}
+
+    data.merge(it[Lux.env] || {})
+  end
+
+  def load
+    to_h.to_readonly
+  end
+
+end