lux-fw 0.1.35 → 0.2.1

data/lib/lux/config/config.rb

@@ -11,35 +11,16 @@ module Lux::Config
   @module_error = []
 
   # requires all files recrusive in, with spart sort
-  def require_all(files)
+  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")
-    glob.reject! { |file| file =~ /_\d+\.rb$/ }
 
     glob.select{ |o| o.index('.rb') }.map{ |o| o.split('.rb')[0]}.each do |ruby_file|
-      require ruby_file rescue file_errors.push(ruby_file)
+      require ruby_file
     end
-
-    file_errors.each { |klass|
-      @klass = klass
-       require klass
-     }
-  rescue
-    puts "* double load error: require_all #{files}\n  #{@klass}.rb\n  #{$!.message}".red
-    raise $!
-  end
-
-  # load specific plugin
-  def plugin(name)
-    files = Dir['%s/lib/plugins/%s/*.rb' % [Lux.fw_root, name]]
-    die('Plugin "%s" load error, no plugin' % name) if files.length == 0
-    for file in files
-      require file
-    end
-    # Lux.log "* plugin :#{name}"
   end
 
   # preview config in development
@@ -70,14 +51,57 @@ module Lux::Config
     true
   end
 
-  def show_load_speed(load_start)
+  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
+
     speed = ((Time.now - load_start)*1000).round.to_s.sub(/(\d)(\d{3})$/,'\1s \2')+'ms'
-    ram   = `ps -o rss -p #{$$}`.chomp.split("\n").last.to_i / 1000
-    opts  = []
-    opts.push Lux.verbose? ? 'verbose'.yellow : 'no-verbose'.green
-    opts.push Lux.config(:auto_code_reload) ? 'auto-code-reload'.yellow : 'no-code-reload'.green
 
-    "* #{'Lux'.white} loaded #{Lux.env('RACK_ENV').green} (#{opts.join(', ')}) 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"
+    production_mode = true
+
+    production_opts = [
+      [:compile_assets,     false],
+      [:auto_code_reload,   false],
+      [:show_server_errors, false],
+      [:log_to_stdout,      false],
+    ]
+
+    opts = production_opts.map do |key, production_value|
+      config_test     = Lux.config(key)
+      config_ok       = production_value == config_test
+      production_mode = false unless config_ok
+
+      data = "#{key} (%s)" % [config_test ? :yes : :no]
+      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}"
+    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
+
+    # name of the session cookie
+    Lux.config.session_cookie_name = '__luxs'
+
+    # Show server errors to a client
+    Lux.config.show_server_errors = false
+
+    # Log debug output to stdout
+    Lux.config.log_to_stdout = false
+
+    # Automatic code reloads in development
+    Lux.config.auto_code_reload   = false
   end
 
 end

data/lib/lux/current/current.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+# we need this for command line
+Thread.current[:lux] ||= { cache: {} }
+
+class Lux::Current
+  # set to true if user is admin and you want him to be able to clear caches in production
+  attr_accessor :can_clear_cache
+
+  attr_accessor :session, :locale
+  attr_reader   :request, :response, :params, :nav, :cookies
+
+  def initialize env=nil
+    env   ||= '/mock'
+    env     = ::Rack::MockRequest.env_for(env) if env.class == String
+    request = ::Rack::Request.new env
+
+    # reset page cache
+    Thread.current[:lux] = { cache:{}, page: self }
+
+    @files_in_use = []
+    @response     = Lux::Response.new
+    @request      = request
+    @cookies      = {}
+    @session      = {}
+
+    for cookie in request.env['HTTP_COOKIE'].to_s.split(/;\s*/).map{ |el| el.split('=',2) }
+      @cookies[cookie[0]] = cookie[1]
+    end
+
+    @session = JSON.parse(Crypt.decrypt(@cookies['__luxs'] || '{}')) rescue {}
+
+    # check for session
+    if Lux.dev? && request.env['HTTP_REFERER'] && request.env['HTTP_REFERER'].index(request.host) && @session.keys.length == 0
+      puts "ERROR: There is no session set!".red
+    end
+
+    # hard sec, bind session to user agent and IP
+    set_and_check_client_unique_hash
+
+    @session = HashWithIndifferentAccess.new(@session)
+
+    ap request.params if request.post? && Lux.config(:log_to_stdout)
+
+    @params = request.params.h_wia
+    Lux::Current::EncryptParams.decrypt @params
+
+    @nav = Lux::Application::Nav.new request
+  end
+
+  def files_in_use file=nil
+    @files_in_use.push file if file && !@files_in_use.include?(file)
+    @files_in_use
+  end
+
+  def set_and_check_client_unique_hash
+    key   = '_c'
+    check = Crypt.sha1(@request.ip.to_s+@request.env['HTTP_USER_AGENT'].to_s)[0,10]
+
+    # force type array
+    @session.delete(key) unless @session[key].class == Array
+
+    # allow 5 mins delay for IP change
+    @session = {} if @session[key] && (@session[key][0] != check && @session[key][1].to_i < Time.now.to_i - Lux.config.session_forced_validity)
+
+    # add new time stamp to every request
+    @session[key] = [check, Time.now.to_i]
+  end
+
+  def domain
+    host = Lux.current.request.host.split('.')
+    host_country = host.pop
+    host_name    = host.pop
+    host_name ? "#{host_name}.#{host_country}" : host_country
+  end
+
+  def host
+    "#{request.env['rack.url_scheme']}://#{request.host}:#{request.port}".sub(':80','')# rescue 'http://locahost:3000'
+  end
+
+  def var
+    Thread.current[:lux][:var] ||= Hashie::Mash.new
+  end
+
+  # cache data in current page
+  def cache key
+    data = Thread.current[:lux][:cache][key]
+    return data if data
+    Thread.current[:lux][:cache][key] = yield
+  end
+
+  # set current.can_clear_cache = true in production for admins
+  def no_cache?
+    @can_clear_cache ||= true if Lux.dev?
+    (@can_clear_cache && @request.env['HTTP_CACHE_CONTROL'].to_s.downcase == 'no-cache') ? true : false
+  end
+
+  def redirect *args
+    response.redirect *args
+  end
+
+  # execute action once per page
+  def once id=nil, data=nil, &block
+    id ||= Digest::SHA1.hexdigest caller[0] if block
+
+    @once_hash ||= {}
+    return @once_hash[id] if @once_hash.key?(id)
+
+    @once_hash[id] = if block_given?
+      yield
+    else
+      data || true
+    end
+  end
+
+  def uid
+    Thread.current[:uid_cnt] ||= 0
+    "uid-#{Thread.current[:uid_cnt]+=1}"
+  end
+
+end
+

data/lib/lux/{page → current}/lib/encrypt_params.rb

@@ -1,6 +1,6 @@
 # used for encrypting and decrypting data in forms
 
-module Lux::Page::EncryptParams
+module Lux::Current::EncryptParams
   extend self
 
   @cnt = 0
@@ -38,7 +38,7 @@ module Lux::Page::EncryptParams
 
     hash
   rescue
-    Lux.log ' Lux::Page::EncryptParams decrypt error'.red
+    Lux.log ' Lux::Current::EncryptParams decrypt error'.red
     {}
   end
 end

data/lib/lux/{page → current}/lib/static_file.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-class Lux::Page::StaticFile
-  DIRS = Dir.entries('./public').select{|d| d[0,1]!='.' && File.directory?("./public/#{d}") } rescue []
-
+class Lux::Current::StaticFile
   MIMME_TYPES = {
     txt:  'text/plain',
     html: 'text/html',
@@ -23,23 +21,25 @@ class Lux::Page::StaticFile
     ttf:   'application/font-ttf',
     eot:   'application/vnd.ms-fontobject',
     otf:   'application/font-otf',
+    doc:   'application/msword'
   }
 
   class << self
-    def deliver(file)
-      new(file).read
+    def deliver file
+      new(file).deliver
     end
   end
 
   ###
 
-  [:body, :status].each { |f| eval "def #{f}(what=nil); Lux.page.#{f}(what); end" }
-  [:headers].each { |f| eval "def #{f}; Lux.page.#{f}; end" }
-
-  def initialize(file)
+  def initialize file
     @file = file
   end
 
+  def c
+    Lux.current
+  end
+
   def is_static_file?
     return false unless @file.index('.')
 
@@ -51,47 +51,51 @@ class Lux::Page::StaticFile
 
     return false if ext.to_s.length == 0
     return false unless MIMME_TYPES[ext.to_sym]
-    return true if path.first.blank? # if /favico.ico is not present return true
-    return DIRS.index(path.first) ? true : false
+
     true
   end
 
-  def read(data=nil)
+  def deliver data=nil
     file = File.exist?(@file) ? @file : Lux.root.join("public#{@file}")
 
     unless File.exists?(file)
       if @file == '/favicon.ico'
-        file = Lux.fw_root.join('public/lux.png')
+        file = Lux.fw_root.join('misc/lux.png')
       else
-        raise NotFoundError, %[Static file "#{@file.split(Lux.root.to_s+'/public')[1]}" not found]
+        raise NotFoundError, %[Static file not found]
       end
     end
 
     ext = file.to_s.split('.').last
     mimme = MIMME_TYPES[ext.to_sym]
+
     unless mimme
-      body('Mimme type not supported')
-      status(404)
+      c.response.body('Mimme type not supported')
+      c.response.status(404)
       return
     end
 
-    Lux.page.content_type = mimme
+    c.response.content_type = mimme
 
     file_mtime = File.mtime(file).utc.to_s
-    key = Crypt.md5(file+file_mtime.to_s)
-    headers['cache-control'] = 'max-age=31536000, no-transform, public'
-    headers['etag'] = key
-    headers['last-modified'] = file_mtime
+    key        = Crypt.sha1(file+file_mtime.to_s)
+
+    c.response.headers['cache-control'] = 'max-age=31536000, public'
+    c.response.headers['etag']          = '"%s"' % key
+    c.response.headers['last-modified'] = file_mtime
 
     # IF etags match, returnfrom cache
-    if Lux.page.request.env['HTTP_IF_NONE_MATCH'] == key
-      status(304)
-      body('not-modified')
+    if c.request.env['HTTP_IF_NONE_MATCH'] == key
+      c.response.status(304)
+      c.response.body('not-modified')
       return
     end
 
+    # c.response.headers['X-Sendfile'] = file
+
     data ||= File.read(file)
-    body(data)
+    c.response.body(data)
+
     true
   end
 end

data/lib/lux/delayed_job/delayed_job.rb

@@ -3,14 +3,14 @@ module Lux::DelayedJob
 
   @@server = nil
 
-  def server=(name)
+  def server= name
     adapter = "Lux::DelayedJob::#{name.to_s.capitalize}"
     @@server = adapter.constantize
   rescue NameError
-    die('No adapter %s not found' % adapter)
+    die 'No adapter %s not found' % adapter
   end
 
-  def push(object, method_to_call=nil)
+  def push object, method_to_call=nil
     die "No DelayedJob server defined" unless @@server
     @@server.push [object, method_to_call]
   end
@@ -31,7 +31,7 @@ module Lux::DelayedJob
     true
   end
 
-  def run!(seconds=2)
+  def run! seconds=2
     puts "JOB QUE> is running for #{@@server}".green
     Thread.new do
       while true

data/lib/lux/error/error.rb

@@ -18,27 +18,36 @@ RateLimitError    ||= Class.new(StandardError)
 module Lux::Error
   extend self
 
-  def try(name)
+  def try name=nil
     begin
       yield
-    rescue
-      Lux.page.status 500
-      log($!)
-      inline('%s (%s)' % [name, $!.class])
+    rescue Exception => e
+      Lux.current.response.status 500
+
+      key = log e
+
+      if Lux.config(:show_server_errors)
+        inline name
+      else
+        name ||= 'Server error occured'
+        name  += "\n\nkey: %s" % key
+
+        Lux.error(name)
+      end
     end
   end
 
   def render data
-    %[<html><head><title>Server error (#{Lux.page.status})</title></head><body style="background:#fdd;"><pre style="color:red; padding:10px; font-size:14pt;">#{data.gsub('<','&lt;')}</pre></body></html>]
+    %[<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
 
-  def show(desc=nil)
-    Lux.page.status(500)
-    data = "Lux #{Lux.page.status} error\n\n#{desc}"
-    Lux.page.body! render(data)
+  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
 
-  def inline(name=nil, o=nil)
+  def inline name=nil, o=nil
     o ||= $!
 
     dmp = [[], []]
@@ -56,13 +65,17 @@ module Lux::Error
     %[<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>]
   end
 
-  def log(exception)
-    return if Lux.env == 'test'
-    return unless Lux.page
+  def log exception
+    return if Lux.env         == 'test'
+    return if exception.class == LocalRaiseError
+    return unless Lux.current
 
-    history = exception.backtrace.reject{ |el| el.index('/gems/') }.map{ |el| el.sub(Lux.root.to_s, '') }.join("\n")
+    # .backtrace.reject{ |el| el.index('/gems/') }
+    history = exception.backtrace
+      .map{ |el| el.sub(Lux.root.to_s, '') }
+      .join("\n")
 
-    data = '%s in %s (user: %s)' % [exception.class, Lux.page.request.url, (Lux.page.var.user.email rescue 'guest')]
+    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
 
@@ -72,5 +85,7 @@ module Lux::Error
     Dir.mkdir(folder) unless Dir.exists?(folder)
 
     File.write("#{folder}/#{key}.txt", data)
+
+    key
   end
 end