lux-fw 0.2.3 → 0.5.32

data/lib/lux/controller/controller.rb

@@ -0,0 +1,241 @@
+# frozen_string_literal: true
+
+# filters stack for call
+# before, before_action, :action, after
+
+class Lux::Controller
+  # define maser layout
+  # string is template, symbol is metod pointer and lambda is lambda
+  class_attribute :layout
+
+  # define helper contest, by defult derived from class name
+  class_attribute :helper
+
+  # before and after any action filter, ignored in controllers, after is called just before render
+  [:before, :before_action, :before_render, :after].each { |filter| class_callback filter }
+
+  class << self
+    # simple shortcut allows direct call to action, bypasing call
+    def action *args
+      new.action(*args)
+    end
+
+    # create mock function, to enable template rendering
+    # mock :index, :login
+    def mock *args
+      args.each do |el|
+        define_method(el) { true }
+      end
+    end
+  end
+
+  ### INSTANCE METHODS
+
+  attr_reader :controller_action
+
+  def initialize
+    # before and after should be exected only once
+    @executed_filters = {}
+    @base_template = self.class.to_s.include?('::') ? self.class.to_s.sub(/Controller$/,'').underscore : self.class.to_s.sub(/Controller$/,'').downcase
+  end
+
+  # because we can call action multiple times
+  # ensure we execute filters only once
+  def filter fiter_name, arg=nil
+    return if @executed_filters[fiter_name]
+    @executed_filters[fiter_name] = true
+
+    Object.class_callback fiter_name, self, @controller_action
+  end
+
+  def cache *args, &block
+    Lux.cache.fetch *args, &block
+  end
+
+  # action(:show)
+  # action(:select', ['users'])
+  def action method_name, *args
+    raise ArgumentError.new('Controller action called with blank action name argument') if method_name.blank?
+
+    method_name = method_name.to_s.gsub('-', '_').gsub(/[^\w]/, '')
+
+    # dev console log
+    Lux.log " #{self.class.to_s}##{method_name}".light_blue
+
+    @controller_action = method_name.to_sym
+    if @controller_format = current.nav.format
+      current.nav.format = nil
+    end
+
+    # format error unless method found
+    report_not_found_error unless respond_to? method_name
+
+    catch :done do
+      filter :before
+      filter :before_action
+      send method_name, *args
+      render
+    end
+
+    filter :after
+
+    throw :done
+  rescue => e
+    response.body { nil }
+    on_error(e)
+  end
+
+  def error *args
+    args.first.nil? ? Lux::Error::AutoRaise : Lux::Error.report(*args)
+  end
+
+  def on_error error
+    raise error
+  end
+
+  def send_file file, opts={}
+    Lux::Response::File.send(file, opts)
+  end
+
+  # render :index
+  # render 'main/root/index'
+  # render text: 'ok'
+  def render name=nil, opts={}
+    on_error Lux::Error.new(404, '%s document Not Found' % @controller_format.to_s.upcase) if @controller_format
+
+    if name.class == Hash
+      opts.merge! name
+    else
+      opts[:template] = name
+    end
+
+    filter :before_render
+
+    opts = opts.to_opts :text, :html, :cache, :template, :json, :layout, :render_to_string, :data, :status, :ttl, :content_type
+
+    response.status opts.status if opts.status
+    response.content_type = opts.content_type if opts.content_type
+
+    page =
+    if opts.cache
+      Lux.cache.fetch(opts.cache, opts.ttl || 3600) { render_resolve(opts) }
+    else
+      render_resolve(opts)
+    end
+
+    if opts.render_to_string
+      page
+    else
+      response.body { page }
+      throw :done
+    end
+  end
+
+  def render_to_string name=nil, opts={}
+    opts[:render_to_string] = true
+    render name, opts
+  end
+
+  def render_javascript name=nil, opts={}
+    opts[:content_type] = :javascript
+    opts[:layout]       = false
+    render name, opts
+  end
+
+  private
+
+  # delegated to current
+  define_method(:current)  { Lux.current }
+  define_method(:request)  { current.request }
+  define_method(:response) { current.response }
+  define_method(:params)   { current.request.params }
+  define_method(:nav)      { current.nav }
+  define_method(:session)  { current.session }
+  define_method(:get?)     { request.request_method == 'GET' }
+  define_method(:post?)    { request.request_method == 'POST' }
+  define_method(:redirect) { |where, flash={}| current.redirect where, flash }
+  define_method(:etag)     { |*args| current.response.etag *args }
+  define_method(:layout)   { |arg| current.var[:controller_layout] = arg }
+
+  # called be render
+  def render_resolve opts
+    # resolve page data, without template
+    page_part = opts.data || render_body(opts)
+
+    # resolve data with layout
+    layout = opts.layout
+    layout = nil   if layout.class == TrueClass
+    layout = false if current.var[:controller_layout].class == FalseClass
+
+    if layout.class == FalseClass
+      page_part
+    else
+      layout_define = layout || self.class.layout
+
+      layout = case layout_define
+        when String
+          'layouts/%s' % layout_define
+        when Symbol
+          send(layout_define)
+        when Proc
+          layout_define.call
+        else
+          'layouts/%s' % @base_template.split('/')[0]
+      end
+
+      Lux::View.new(layout, helper).render_part { page_part }
+    end
+  end
+
+  def render_body opts
+    if template = opts.template
+      template = template.to_s
+      template = "#{@base_template}/#{template}" unless template.starts_with?('/')
+    else
+      template = "#{@base_template}/#{@controller_action}"
+    end
+
+    Lux::View.render_part(template, helper)
+  end
+
+  def halt status, desc=nil
+    response.status = status
+    response.body   = desc || "Hatlt code #{status}"
+
+    throw :done
+  end
+
+  def namespace
+    @base_template.split('/')[0].to_sym
+  end
+
+  def helper ns=nil
+    Lux::View::Helper.new self, :html, self.class.helper, ns
+  end
+
+  def report_not_found_error
+    raise Lux::Error.not_found unless Lux.config(:dump_errors)
+
+    err = [%[Method "#{@controller_action}" not found found in #{self.class.to_s}]]
+    err.push "You have defined \n- %s" % (methods - Lux::Controller.instance_methods).join("\n- ")
+
+    return Lux.error err.join("\n\n")
+  end
+
+  def respond_to ext=nil
+    fmt = @controller_format
+    @controller_format = nil
+
+    if ext
+      if ext == fmt
+        yield if block_given?
+        true
+      elsif fmt
+        on_error Lux::Error.new(404, '%s document Not Found' % fmt.to_s.upcase)
+      end
+    else
+      yield fmt
+    end
+  end
+
+end

data/lib/lux/current/current.rb

@@ -8,11 +8,11 @@ class Lux::Current
   attr_accessor :can_clear_cache
 
   attr_accessor :session, :locale
-  attr_reader   :request, :response, :params, :nav, :cookies
+  attr_reader   :request, :response, :nav
 
   def initialize env=nil
     env   ||= '/mock'
-    env     = ::Rack::MockRequest.env_for(env) if env.class == String
+    env     = ::Rack::MockRequest.env_for(env) if env.is_a?(String)
     request = ::Rack::Request.new env
 
     # reset page cache
@@ -21,52 +21,24 @@ class Lux::Current
     @files_in_use = []
     @response     = Lux::Response.new
     @request      = request
-    @cookies      = {}
-    @session      = {}
+    @session      = Lux::Current::Session.new request
 
-    for cookie in request.env['HTTP_COOKIE'].to_s.split(/;\s*/).map{ |el| el.split('=',2) }
-      @cookies[cookie[0]] = cookie[1]
+    # remove empty paramsters in GET request
+    if request.request_method == 'GET'
+      for el in request.params.keys
+        request.params.delete(el) if request.params[el].blank?
+      end
     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)
+    # indiferent access
+    request.instance_variable_set(:@params, request.params.h_wia) if request.params.keys.length > 0
 
+    Lux::Current::EncryptParams.decrypt request.params
     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
@@ -91,8 +63,8 @@ class Lux::Current
 
   # 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
+    @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
@@ -104,13 +76,10 @@ class Lux::Current
     id ||= Digest::SHA1.hexdigest caller[0] if block
 
     @once_hash ||= {}
-    return @once_hash[id] if @once_hash.key?(id)
+    return if @once_hash[id]
+    @once_hash[id] = true
 
-    @once_hash[id] = if block_given?
-      yield
-    else
-      data || true
-    end
+    block_given? ? yield : data
   end
 
   def uid
@@ -118,5 +87,22 @@ class Lux::Current
     "uid-#{Thread.current[:uid_cnt]+=1}"
   end
 
+  def files_in_use file=nil
+    if block_given?
+      return yield(file) unless @files_in_use.include?(file)
+    end
+
+    return @files_in_use unless file
+    return unless Lux.config(:log_to_stdout)
+
+    file = file.sub './', ''
+
+    if @files_in_use.include?(file)
+      true
+    else
+      @files_in_use.push file
+      false
+    end
+  end
 end
 

data/lib/lux/current/lib/session.rb

@@ -0,0 +1,72 @@
+# vars
+# Lux.config.session_cookie_name
+# Lux.config.session_cookie_max_age
+# Lux.config.session_cookie_domain
+
+class Lux::Current::Session
+  def initialize request
+    # how long will session last if BROWSER or IP change
+    Lux.config.session_forced_validity ||= 10.minutes.to_i
+
+    # name of the session cookie
+    @cookie_name = Lux.config.session_cookie_name ||= 'lux_' + Crypt.sha1(Lux.config.secret)[0,4].downcase
+    @request     = request
+    @session     = JSON.parse(Crypt.decrypt(request.cookies[@cookie_name] || '{}')) rescue {}
+
+    security_check
+  end
+
+  def [] key
+    @session[key.to_s.downcase]
+  end
+
+  def []= key, value
+    @session[key.to_s.downcase] = value
+  end
+
+  def delete key
+    @session.delete key.to_s.downcase
+  end
+
+  def generate_cookie
+    encrypted = Crypt.encrypt(@session.to_json)
+
+    if @request.cookies[@cookie_name] != encrypted
+      cookie = []
+      cookie.push [@cookie_name, encrypted].join('=')
+      cookie.push 'Max-Age=%s' % (Lux.config.session_cookie_max_age || 1.week.to_i)
+      cookie.push "Path=/"
+      cookie.push "Domain=#{Lux.config.session_cookie_domain}" if Lux.config.session_cookie_domain
+      cookie.push "secure" if Lux.config.host.include?('https:')
+      cookie.push "HttpOnly"
+
+      cookie.join('; ')
+    else
+      nil
+    end
+  end
+
+  def merge! hash={}
+    hash.keys.each { |k| self[k] = hash[k] }
+  end
+
+  def hash
+    @session.dup
+  end
+
+  private
+
+  def security_check
+    key   = '_c'
+    check = Crypt.sha1(@request.ip.to_s+@request.env['HTTP_USER_AGENT'].to_s)[0, 5]
+
+    # force type array
+    @session.delete(key) unless @session[key].class == Array
+
+    # allow 10 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
+end

data/lib/lux/delayed_job/delayed_job.rb

@@ -1,24 +1,29 @@
 module Lux::DelayedJob
   extend self
 
-  @@server = nil
+  attr_reader :server
+
+  @server = :memory
 
   def server= name
     adapter = "Lux::DelayedJob::#{name.to_s.capitalize}"
-    @@server = adapter.constantize
+    @server = adapter.constantize
   rescue NameError
     die 'No adapter %s not found' % adapter
   end
 
   def push object, method_to_call=nil
-    die "No DelayedJob server defined" unless @@server
-    @@server.push [object, method_to_call]
+    die "No DelayedJob server defined" unless @server
+    @server.push [object, method_to_call]
   end
 
   def pop
-    obj, method_to_call = @@server.pop
+    obj, method_to_call = @server.pop
+
     return unless obj
+
     puts "JOB POP> #{obj.to_s}.#{method_to_call}".yellow
+
     if method_to_call
       begin
         obj.send(method_to_call)
@@ -28,11 +33,13 @@ module Lux::DelayedJob
     else
       eval(obj)
     end
+
     true
   end
 
-  def run! seconds=2
-    puts "JOB QUE> is running for #{@@server}".green
+  def run! seconds=1
+    puts "JOB QUE> is running for #{@server}".green
+
     Thread.new do
       while true
         print '.'

data/lib/lux/delayed_job/lib/memory.rb

@@ -1,14 +1,16 @@
 module Lux::DelayedJob::Memory
   extend self
 
-  @@JOBS = []
+  @jobs = []
 
-  def push(data)
-    @@JOBS.push data
-    Thread.new { true while Lux::DelayedJob.pop }
+  def push data
+    @jobs.push data
+
+    # delayed jobs in memory are resolved asap
+    Thread.new { true while pop }
   end
 
   def pop
-    @@JOBS.shift
+    @jobs.shift
   end
 end

data/lib/lux/delayed_job/lib/redis.rb

@@ -3,7 +3,7 @@ module Lux::DelayedJob
     extend self
 
     def que
-      @@server ||= Lux.config(:redis_server)
+      @server ||= Lux.config(:redis_server)
     end
 
     def push(list)