lux-fw 0.1.17

data/lib/lux/lux.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+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
+  CONFIG ||= Hashie::Mash.new
+  EVENTS ||= {}
+
+  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' }
+
+  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)
+    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]
+  end
+
+  def page
+    Thread.current[:lux][:page]
+  end
+
+  def page=(what)
+    Thread.current[:lux][:page] = what
+  end
+
+  def cache
+    Lux::Cache
+  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
+  end
+
+  def error data
+    Lux::Error.show(data)
+  end
+
+  def log what
+    return unless Lux.config(:log_to_stdout)
+    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)
+    else
+      for func in EVENTS[name]
+        ref.instance_eval(&func)
+      end
+    end
+  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
+    if block_given?
+      BACKGROUND_THREADS.push Thread.new { yield }
+    elsif args[0]
+      # Lux.delay(mail_object, :deliver)
+      Lux::DelayedJob.push(*args)
+    else
+      Lux::DelayedJob
+    end
+  end
+
+  def speed loops=1
+    render_start = Time.now
+    loops.times { yield }
+    num = ((Time.now-render_start)*1000).to_i.to_s
+    num = num.sub(/(\d)(\d{3})$/,'\1s \2')
+    num = "#{num}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
+  end
+
+end
+
+# handy :)
+# renders full pages and exposes page object (req, res) in yiled
+# for easy and powerful testing
+# Hash :qs, Hash :post, String :method, Hash :cookies, Hash :session
+# https://github.com/rack/rack/blob/master/test/spec_request.rb
+def Lux(path, in_opts={}, &block)
+  allowed_opts = [:qs, :post, :method, :session, :cookies]
+  in_opts.keys.each { |k| die "#{k} is not allowed as opts param. allowed are #{allowed_opts}" unless allowed_opts.index(k) }
+
+  opts = {}
+
+  if in_opts[:post]
+    opts[:query_string] = in_opts[:post]
+    opts[:request_method] = :post
+  else
+    opts[:query_string] = in_opts[:qs] || {}
+    opts[:request_method] ||= in_opts[:method] || :get
+  end
+  opts[:request_method] = opts[:request_method].to_s.upcase
+  opts[:query_string] = opts[:query_string].to_query if opts[:query_string].class.to_s == 'Hash'
+
+  if path[0,4] == 'http'
+    parsed = URI.parse(path)
+    opts[:server_name] = parsed.host
+    opts[:server_port] = parsed.port
+    path = '/'+path.split('/', 4).last
+  end
+
+  env = Rack::MockRequest.env_for(path)
+  env[:input] = opts[:post] if opts[:post]
+  for k,v in opts
+    env[k.to_s.upcase] = v
+  end
+
+  page = Lux::Page.prepare(env)
+  page.session = in_opts[:session] if in_opts[:session]
+
+  return page.instance_exec &block if block_given?
+
+  response = page.render
+  body = response[2].join('')
+  body = JSON.parse body if response[1]['content-type'].index('/json')
+
+  { status: response[0], headers: response[1], body: body }.h
+end
+
+require_relative 'config/config'

data/lib/lux/mailer/mailer.rb

@@ -0,0 +1,73 @@
+# sugessted usage
+# Mailer.deliver(:confirm_email, 'rejotl@gmailcom')
+# Mailer.render(:confirm_email, 'rejotl@gmailcom')
+
+# natively works like
+# Mailer.prepare(:confirm_email, 'rejotl@gmailcom').deliver
+# Mailer.prepare(:confirm_email, 'rejotl@gmailcom').body
+
+# Rails mode via method missing is suported
+# Mailer.confirm_email('rejotl@gmailcom').deliver
+# Mailer.confirm_email('rejotl@gmailcom').body
+
+class Lux::Mailer
+
+  BeforeAndAfter.define self, :before, :after
+
+  attr_reader :subject, :to, :from
+
+  # Mailer.prepare(:confirm_email, 'rejotl@gmailcom')
+  def self.prepare(template, *args)
+    obj = new
+    obj.instance_variable_set :@_template, template
+
+    BeforeAndAfter.execute(obj, :before)
+    obj.send(template, *args)
+    BeforeAndAfter.execute(obj, :after)
+
+    obj
+  end
+
+  def self.render(method_name, *args)
+    send(method_name, *args).body
+  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
+
+    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[:content_type] = 'text/html; charset=UTF-8'
+    m.deliver!
+  end
+
+  def deliver_later
+     Lux.delay(self, :deliver)
+  end
+
+  def self.deliver
+    send(method_name, *args).deliver
+  end
+
+  def body
+    Lux::Template.render_with_layout("mailer/#{@_template}", instance_variables_hash)
+  end
+
+  def subject
+    @subject
+  end
+
+  def self.method_missing(method_sym, *args)
+    prepare(method_sym, *args)
+  end
+
+end

data/lib/lux/page/lib/encrypt_params.rb

@@ -0,0 +1,44 @@
+# used for encrypting and decrypting data in forms
+
+module Lux::Page::EncryptParams
+  extend self
+
+  @cnt = 0
+
+  # encrypt_param('dux', 'foo')
+  # <OpenStruct name="_data_1", value="eyJ0eXAiOiJKV1QiLCJhbGciOi..."
+  def encrypt name, value
+    base = name.include?('[') ? name.split(/[\[\]]/).first(2).join('::') : name
+    base += '#%s' % value
+
+    OpenStruct.new(name: "_data_#{@cnt+=1}", value: Crypt.encrypt(base))
+  end
+
+  def hidden_input name, value
+    data = encrypt name, value
+
+    %[<input type="hidden" name="#{data.name}" value="#{data.value}" />]
+  end
+
+  # decrypts params starting with _data_
+  def decrypt hash
+    for key in hash.keys
+      next unless key.starts_with?('_data_')
+      data = Crypt.decrypt(hash.delete(key))
+      data, value = data.split('#', 2)
+      data = data.split('::')
+
+      if data[1]
+        hash[data[0]] ||= {}
+        hash[data[0]][data[1]] = value
+      else
+        hash[data[0]] = value
+      end
+    end
+
+    hash
+  rescue
+    Lux.log ' Lux::Page::EncryptParams decrypt error'.red
+    {}
+  end
+end

data/lib/lux/page/lib/flash.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+class Lux::Page::Flash
+
+  # flash.info 'messsage ...'
+  # flash.info = 'messsage ...'
+  def self.add_type name
+    define_method(name) { |message| add name, message }
+    eval "alias #{name}= #{name}"
+  end
+
+  add_type :info
+  add_type :error
+  add_type :warning
+
+  ###
+
+  def initialize h=nil
+    @msg = h || {}
+  end
+
+  def clear
+    to_h.tap { @msg = {} }
+  end
+
+  def to_h
+    @msg
+  end
+
+  # clears white space, replaces quotes
+  def clear_for_js
+    {}.tap do |msg|
+      clear.each do |k, v|
+        msg[k] = v.join(', ').gsub(/\s+/, ' ')
+      end
+    end
+  end
+
+  private
+
+  def add name, message
+    @msg[name] ||= []
+
+    return if @msg[name].last == message
+    return if @msg[name].length > 4
+
+    @msg[name].push message.to_s
+  end
+end

data/lib/lux/page/lib/static_file.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+class Lux::Page::StaticFile
+  DIRS = Dir.entries('./public').select{|d| d[0,1]!='.' && File.directory?("./public/#{d}") } rescue []
+
+  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',
+  }
+
+  class << self
+    def deliver(file)
+      new(file).read
+    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)
+    @file = file
+  end
+
+  def is_static_file?
+    return false unless @file.index('.')
+
+    path = @file.split('/')
+    path.pop
+
+    file = path.shift
+    ext = @file.split('.').last
+
+    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)
+    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')
+      else
+        raise NotFoundError, %[Static file "#{@file.split(Lux.root.to_s+'/public')[1]}" 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)
+      return
+    end
+
+    Lux.page.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
+
+    # IF etags match, returnfrom cache
+    if Lux.page.request.env['HTTP_IF_NONE_MATCH'] == key
+      status(304)
+      body('not-modified')
+      return
+    end
+
+    data ||= File.read(file)
+    body(data)
+    true
+  end
+end

data/lib/lux/page/page.rb

@@ -0,0 +1,271 @@
+# frozen_string_literal: true
+
+# we need this for command line
+Thread.current[:lux] ||= {}
+Thread.current[:lux][:cache] ||= {}
+
+class Lux::Page
+  attr_accessor :headers, :cookies, :session, :files_in_use
+  attr_reader   :params, :request, :nav
+
+  BeforeAndAfter.define self, :before, :after
+
+  class << self
+    # expects Rack env object but can acceept url
+    # we need this for testing
+    def prepare env
+      env     = Rack::MockRequest.env_for(env) if env.class == String
+      request = Rack::Request.new env
+      page    = Lux::Page.new request
+
+      # reset page cache
+      Thread.current[:lux] = { cache:{}, page:page }
+
+      page
+    end
+
+    # default rack env call
+    def call env=nil
+      prepare(env).render
+    rescue
+      Lux::Error.log $!
+
+      raise $! if Lux.config(:show_server_errors)
+
+      [500, {}, ['Lux server error']]
+    end
+  end
+
+  ###
+
+  def initialize(request)
+    @render_start = Time.now
+    @files_in_use = []
+    @request = request
+    @headers = {}
+    @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 = @cookies['__luxs'] ? (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
+
+    @session = HashWithIndifferentAccess.new(@session)
+    @session['_junk'] = Crypt.uid
+
+    @params = request.params.h_wia
+    Lux::Page::EncryptParams.decrypt @params
+
+    @nav = Lux::Controller::Nav.new request
+  end
+
+  def status num=nil
+    Lux.log caller if num == 500
+    return @status if @status
+    if num
+      if num.is_numeric?
+        @status ||= num.to_i
+      else
+        @status = case num.to_s
+          when 'StandardError';     400
+          when 'BadRequestError';   400
+          when 'UnauthorizedError'; 401
+          when 'ForbidenError';     403
+          when 'NotFoundError';     404
+          when 'RateLimitError';    503
+          else; 500
+        end
+      end
+    end
+
+    @status
+  end
+
+  def body what=nil
+    @body ||= what
+
+    if @body && block_given?
+      @body = yield @body
+      Lux.error 'Lux.page.body is not a string (bad page.body filter)' unless @body.is_a?(String)
+    end
+
+    @body
+  end
+
+  def body= what
+    body(what)
+  end
+
+  def body! what
+    @body = what
+  end
+
+  def flash message=nil
+    @flash ||= Flash.new(@session[:lux_flash])
+
+    message ? @flash.error(message) : @flash
+  end
+
+  def base_domain
+    host = Lux.page.request.host.split('.')
+    host_country = host.pop
+    host_name    = host.pop
+    host_name ? "#{host_name}.#{host_country}" : host_country
+  end
+
+  def var
+    Thread.current[:lux][:var] ||= Hashie::Mash.new
+  end
+
+  def host
+    "#{request.env['rack.url_scheme']}://#{request.host}:#{request.port}".sub(':80','') rescue 'http://locahost:3000'
+  end
+
+  def no_cache? force=nil
+    return false if !force && Lux.prod?
+    Lux.page.request.env['HTTP_CACHE_CONTROL'] == 'no-cache' ? true : false
+  rescue
+    false
+  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 : "#{Lux.page.host}#{where}"
+    @body = %[redirecting to #{@headers['location']}\n\n#{opts.values.join("\n")}]
+  end
+
+  def permanent_redirect(where)
+    redirect(where, status:301)
+  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
+
+    @content_type = type
+  end
+
+  def content_type=(type)
+    content_type(type)
+  end
+
+  def etag(*args)
+    @headers['etag'] ||= %[W/"#{Lux.cache.generate_key(args)}"]
+
+    if Lux.page.request.env['HTTP_IF_NONE_MATCH'] == @headers['etag']
+      if Lux.config(:perform_caching)
+        Lux.page.status(304)
+        Lux.page.body 'not-modified'
+        return true
+      else
+        print ' 304>' if Lux.page.status != 304 && Lux.verbose?
+      end
+    end
+    false
+  end
+
+  def once(id, data=nil)
+    @once_hash ||= {}
+    return if @once_hash[id]
+    @once_hash[id] = true
+    data || yield
+  end
+
+  def process_body
+    # if @body is not set, this is error now
+    unless @body
+      @status = 500
+      @body = 'Page BODY not defined. Maybe you did not call cell action but method instad.'
+    end
+
+    # respond as JSON if we recive hash
+    if @body.kind_of?(Hash)
+      @body = Lux.dev? ? JSON.pretty_generate(@body) : JSON.generate(@body)
+      if Lux.page.request.params[:callback]
+        @body = "#{@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
+
+    # show out of process errors if enables and if is html page
+    # becasue for eaxmple we dont want to show error page instead of image
+    # we want user to see it
+    if Lux.config(:show_server_errors) && @content_type == 'text/html' && File.exist?(Lux::Error::OUT_OF_PROCESS_ERROR_PATH)
+      data = File.read(Lux::Error::OUT_OF_PROCESS_ERROR_PATH)
+      File.unlink(Lux::Error::OUT_OF_PROCESS_ERROR_PATH)
+      @body = Lux::Error::render data
+    end
+
+    if request.host =~ %r{^[\d\.]+$} # if request is IP
+      domain = request.host
+    else
+      domain = base_domain
+      domain = domain.index('.') ? ".#{domain}" : domain
+    end
+
+    @session[:lux_flash] = flash.to_h
+
+    # skip adding of cookies and time to strong etag parameters
+    if !@headers['etag'] || @headers['etag'].index('/')
+      @headers['set-cookie']  = "__luxs=#{Crypt.encrypt(@session.to_json)}; Expires=#{(Time.now+1.month).utc}; Path=/; Domain=#{domain};"
+      @headers['x-lux-speed'] = "#{((Time.now-@render_start)*1000).round(1)}ms"
+    end
+
+    @headers['content-type']  ||= "#{@content_type}; charset=utf-8"
+
+    # if "no-store" is present then HTTP_IF_NONE_MATCH is not sent from browser
+    @headers['cache-control'] ||= 'must-revalidate, %s, max-age=0' % Lux.page.var.user ? :private : :public
+
+    Lux.page.etag(@body) if Lux.page.request.request_method == 'GET'
+    @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, [@body]]
+  end
+
+  def render
+    Lux.log "\n#{Lux.page.request.request_method.white} #{Lux.page.request.path.white}"
+
+    Lux::Config.live_require_check! if Lux.config(:auto_code_reload)
+
+    BeforeAndAfter.execute(self, :before)
+    Lux::Controller.new.rescued_main
+    BeforeAndAfter.execute(self, :after)
+
+    process_body
+  end
+
+end
+
+