lux-fw 0.5.36 → 0.6.2

data/lib/lux/response/response.rb

@@ -2,223 +2,311 @@
 # response.max_age = 10
 # response.public  = true
 # response.status  = 500
-class Lux::Response
-  # define in seconds, how long should page be accessible in client cache
-  # if defined, cache becomes public and can be cache by proxies
-  # use with care.only for static resources and
-  attr_reader :max_age
-  attr_accessor :headers, :cookies, :content_type, :status
-
-  def initialize
-    @render_start = Time.monotonic
-    @headers      = Lux::Response::Header.new
-    @max_age      = 0
-  end
-
-  def current
-    Lux.current
-  end
-
-  def header name, value=:_
-    @headers[name] = value if value != :_
-    @headers[name]
-  end
-
-  def max_age= age
-    @max_age = age.to_i
-  end
-
-  # http 103
-  def early_hints link=nil, type=nil
-    @early_hints ||= []
-    @early_hints.push [link, type] if type && !@early_hints.include?(link)
-    @early_hints
-  end
+module Lux
+  class Response
+    # define in seconds, how long should page be accessible in client cache
+    # if defined, cache becomes public and can be cache by proxies
+    # use with care.only for static resources and
+    attr_reader :max_age, :render_start
+    attr_accessor :headers, :cookies, :content_type, :status
+
+    def initialize
+      @render_start = Time.monotonic
+      @headers      = Lux::Response::Header.new
+      @max_age      = 0
+    end
 
-  def etag *args
-    unless @headers['etag']
-      args.push current.request.url
+    def current
+      Lux.current
+    end
 
-      key = '"%s"' % Lux.cache.generate_key(args)
-      key = 'W/%s' % key unless max_age > 0
+    # header['x-foo']
+    # header 'x-foo', 'bar'
+    # header @hash
+    def header *args
+      if args.first
+        if args.first.class == Hash
+          args.each{|k,v| header k, v.to_s if k && v }
+        else
+          key = args.first.to_s.downcase
+          @headers[key] = args[1].to_s if args[1] != :_
+          @headers[key]
+        end
+      end
 
-      @headers['etag'] = key
+      @headers
     end
 
-    if !@body && current.request.env['HTTP_IF_NONE_MATCH'] == @headers['etag']
-      status 304
-      body   'not-modified'
+    def max_age= age, stale_while_revalidate = nil
+      @max_age = age.to_i
+      @stale_while_revalidate = stale_while_revalidate
     end
-  end
 
-  def status num=nil
-    return @status unless num
-    raise 'Bad status value [%s]' % num unless num.is_numeric?
+    # http 103
+    def early_hints link=nil, type=nil
+      @early_hints ||= []
+      @early_hints.push [link, type] if type && !@early_hints.include?(link)
+      @early_hints
+    end
 
-    @status ||= num
-    @status
-  end
-  alias :status= :status
+    def etag *args
+      unless @headers['etag']
+        key = '"%s"' % Lux.cache.generate_key(current.request.url, args)
+        key = 'W/%s' % key unless max_age > 0
+        @headers['etag'] = key
+      end
 
-  def halt status=nil, msg=nil
-    @status = status || 400
-    @body   = msg if msg
+      if !status && !current.no_cache?(true) && current.request.env['HTTP_IF_NONE_MATCH'] == @headers['etag']
+        if Lux.env.no_cache?
+          Lux.log ' * etag match (skiping for env.no_cache)' unless current.nav.format
+        else
+          Lux.log ' * etag match'
+          body 'not-modified', status: 304
+          true
+        end
+      else
+        false
+      end
+    end
 
-    throw :done
-  end
+    def status num = nil
+      return @status unless num
 
-  def body body_data=nil, status=nil
-    @status = status      if status
-    @body   = body_data   if body_data
-    @body   = yield @body if block_given?
-    @body
-  end
+      unless num.is_numeric?
+        Lux.info %[LUX error: Not numeric status code "#{num}", reverting to 400]
+        num = 400
+      end
 
-  def body?
-    !!@body
-  end
+      @status ||= num
+      @status
+    end
+    alias :status= :status
 
-  def content_type type=nil
-    return @content_type unless type
+    def halt status = nil, msg = nil
+      @status = status || 400
+      @body   = msg if msg
+    end
 
-    if type.is_a?(Symbol)
-      case type
-      when :javascript then 'application/javascript'
-      when :json       then 'application/json'
-      when :text       then 'text/plain'
-      when :html       then 'text/html'
+    # response.body 'foo'
+    # response.body 'foo', status: 400, content_type: :js
+    # response.body { 'foo' }
+    # response.body({...}) { 'foo' }
+    def body data = nil, opts = nil
+      if block_given?
+        # block can override data set
+        opts = data || {}
+        @body = yield @body
+        @body
+      elsif data
+        unless @body
+          opts ||= {}
+          opts.is!(Hash).each {|k,v| self.send k, *v }
+          @body = data
+        end
+        throw :done
       else
-        raise ArgumentError.new('Bad content type')
+        @body
       end
     end
+    alias :body= :body
 
-    @content_type = type
-  end
+    def body?
+      !!@body
+    end
 
-  def content_type= type
-    content_type type
-  end
+    def content_type in_type = nil
+      return @content_type unless in_type
 
-  def flash message=nil
-    @flash ||= Flash.new current.session[:lux_flash]
+      in_type = :js if in_type == :javascript
 
-    message ? @flash.error(message) : @flash
-  end
+      if in_type.is_a?(Symbol)
+        type = Lux::Response::File::MIMME_TYPES[in_type]
+        raise ArgumentError.new('Bad content type: %s' % in_type) unless type
+      else
+        type = in_type
+      end
 
-  def send_file file, opts={}
-    ::Lux::Response::File.new(file, opts).send
-  end
+      @content_type ||= type
+    end
 
-  # redirect '/foo'
-  # redirect :back, info: 'bar ...'
-  def redirect where, opts={}
-    where  = current.request.env['HTTP_REFERER'].or('/') if where == :back
-    where  = "#{current.request.path}#{where}" if where[0,1] == '?'
-    where  = current.host + where unless where.include?('://')
+    def content_type= type
+      content_type type
+    end
 
-    # local redirect
-    if where.include?(current.host)
-      redirect_var = Lux.config.redirect_var || :_r
+    def flash message = nil
+      @flash ||= Flash.new current.session[:lux_flash]
+      message ? @flash.error(message) : @flash
+    end
+
+    def send_file file, opts = {}
+      ::Lux::Response::File.new(opts.merge(file: file)).send
+    end
+
+    # redirect_to '/foo'
+    # redirect_to :back, info: 'bar ...'
+    def redirect_to where, opts = {}
+      Lux.log { ' Redirected to "%s" from: %s' % [where, Lux.app_caller] }
+
+      opts = { info: opts } if opts.is_a?(String)
+
+      if where == :self
+        where = current.request.path
+      elsif where == :back
+        where  = current.request.env['HTTP_REFERER'].or('/')
+      elsif where[0,1] == '?'
+        where  = "#{current.request.path}#{where}"
+      # elsif !where.include?('://')
+      #   where = current.host + where
+      end
 
-      url = Url.new where
-      url[redirect_var] = current.request.params[redirect_var].to_i + 1
+      if where.start_with?('/') || opts.delete(:redirect_tracker)
+        redirect_var = Lux.config[:redirect_var] || :_r
+        url = Url.new where
+        url[redirect_var] = current.request.params[redirect_var].to_i + 1
 
-      where =
-        if opts.delete(:silent)
+        where = if opts.delete(:silent)
           url.delete redirect_var
           url.to_s
         else
-          url[redirect_var] > 3 ? '/' : url.to_s
+          url[redirect_var].to_i > 3 ? '/' : url.to_s
         end
+      end
+
+      @status = opts.delete(:status) || 302
+      opts.map { |k,v| flash.send(k, v) }
+
+      @body = <<~PAGE
+        <html>
+          <head>
+            <title>redirecting</title>
+          </head>
+          <body>
+            <p>redirecting to #{where}</p>
+            <p>#{opts.values.join("\n")}</p>
+            <script>location.href = '#{where}'</script>
+          </body>
+        </html>
+      PAGE
+
+      @headers['location'] = where
+      @headers['access-control-expose-headers'] ||= 'Location'
+
+      # if we do not have this here, controller will proceed executing code after redirect_to
+      throw :done
     end
 
-    @status = opts.delete(:status) || 302
-    opts.map { |k,v| flash.send(k, v) }
+    def permanent_redirect_to where
+      redirect_to where, status: 301
+    end
 
-    @body = %[redirecting to #{where}\n\n#{opts.values.join("\n")}]
+    # auth { |user, pass| [user, pass] == ['foo', 'bar'] }
+    def auth realm: nil, message: nil
+      if auth = current.request.env['HTTP_AUTHORIZATION']
+        credentials = auth.to_s.split('Basic ', 2)[1].unpack("m*").first.split(':', 2)
+        return true if yield *credentials
+      end
 
-    @headers['location'] = where
-    @headers['access-control-expose-headers'] ||= 'Location'
+      header('WWW-Authenticate', 'Basic realm="%s"' % realm.or('default'))
+      body message || 'HTTP 401 Authorization needed', status: 401
+    end
 
-    throw :done
-  end
+    def render
+      write_response_body
+      write_response_header
 
-  def permanent_redirect where
-    redirect where, status:301
-  end
+      @status ||= 200
 
-  # auth { |user, pass| [user, pass] == ['foo', 'bar'] }
-  def auth relam=nil
-    if auth = current.request.env['HTTP_AUTHORIZATION']
-      credentials = auth.to_s.split('Basic ', 2)[1].unpack("m*").first.split(':', 2)
-      return true if yield *credentials
-    end
+      Lux.log do
+        log_data  = " #{@status}, #{@data.to_s.length}, #{(@body.bytesize.to_f/1024).round(1)}kb, #{@headers['x-lux-speed']}"
+        log_data += " (#{current.request.url})" if current.nav.format
 
-    status 401
-    header('WWW-Authenticate', 'Basic realm="%s"' % relam.or('default'))
-    body 'HTTP 401 Authorization needed'
-    throw :done
-  end
+        [200, 304].include?(@status) ? log_data : log_data.magenta
+      end
 
-  def write_response_body
-    unless @body
-      @status = 204
-      @body = 'Lux HTTP ERROR 204: NO CONTENT'
+      if current.request.request_method == 'HEAD'
+        @body = ''
+      end
+
+      [@status, @headers.to_h, [@body]]
     end
 
-    # respond as JSON if we recive hash
-    if @body.kind_of?(Hash)
-      @body = Lux.dev? ? JSON.pretty_generate(@body) : JSON.generate(@body)
+    def rack klass
+      data = klass.call current.env
+      @headers.merge data[1]
+      body data[2].first, status:data[0]
+    end
 
-      if current.request.params[:callback]
-        @body = "#{current.request.params[:callback]}(#{ret})"
-        @content_type ||= 'text/javascript'
-      else
-        @content_type ||= 'application/json'
-      end
+    def public?
+      @headers['cache-control'].to_s.include?('public')
+    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'
+    def cached?
+      @max_age > 0
+    end
+
+    def is_bot?
+      current.request.user_agent.to_s.include?('Googlebot')
     end
-  end
 
-  def write_response_header
-    # cache-control
-    @headers['cache-control'] ||= Proc.new do
-      cc = ['max-age=%d' % max_age]
-      cc.push max_age > 0 ? 'public, no-cache' : 'private, must-revalidate'
-      cc.join(', ')
-    end.call
+    private
 
-    current.session[:lux_flash] = flash.to_h
+    def write_response_body
+      unless @body
+        @status = 204
+        @body = 'Lux HTTP ERROR 204: NO CONTENT'
+      end
+
+      # respond as JSON if we recive hash
+      if @body.kind_of?(Hash)
+        @body = Lux.env.screen_log? ? JSON.pretty_generate(@body) : JSON.generate(@body)
+
+        if current.request.params[:callback]
+          @body = "#{current.request.params[:callback]}(#{ret})"
+          @content_type ||= 'text/javascript'
+        else
+          @content_type ||= 'application/json'
+        end
 
-    # dont annd cookies to public pages (images, etc..)
-    unless @headers['cache-control'].index('public')
-      cookie = current.session.generate_cookie
-      @headers['set-cookie'] = cookie if cookie
+        @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
     end
 
-    etag(@body) if current.request.request_method == 'GET'
+    def write_response_header
+      current.session[:lux_flash] = flash.to_h
 
-    @headers['x-lux-speed']     = "#{((Time.monotonic - @render_start)*1000).round(1)} ms"
-    @headers['content-type']  ||= "#{@content_type}; charset=utf-8"
-    @headers['content-length']  = @body.bytesize.to_s
+      if current.session[:lux_flash].keys.length != 0
+        self.max_age = 0
+      end
 
-    # if "no-store" is present then HTTP_IF_NONE_MATCH is not sent from browser
-  end
+      # cache-control
+      @headers['cache-control'] ||= begin
+        cc = []
+        cc.push max_age > 0 ? 'public' : 'private, must-revalidate'
+        cc.push 'max-age=%d' % max_age
+        cc.push 'stale-while-revalidate=%d' % @stale_while_revalidate if @stale_while_revalidate
+        cc.join(', ')
+      end
 
-  def render
-    write_response_body
-    write_response_header
+      if self.max_age == 0 && !self.is_bot?
+        cookie = current.session.generate_cookie
+        @headers['set-cookie'] = cookie if cookie
+      end
 
-    @status ||= 200
-    Lux.log " #{@status}, #{@headers['x-lux-speed']}"
+      if current.request.request_method == 'GET'
+        catch(:done) { etag(@body) }
+      end
 
-    [@status, @headers.to_h, [@body]]
+      # @headers['access-control-allow-credentials'] = 'true'
+      # if "no-store" is present then HTTP_IF_NONE_MATCH is not sent from browser
+      @headers['x-lux-speed']     = "#{((Time.monotonic - @render_start)*1000).round(1)}ms"
+      @headers['content-type']  ||= "#{@content_type}; charset=utf-8"
+      @headers['content-length']  = @body.bytesize.to_s
+      @headers['content-length']  = @body.bytesize.to_s
+    end
   end
-
 end

data/lib/lux/template/helper.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module Lux
+  class Template
+    class Helper
+      attr_reader :_source_object
+
+      # create helper object that cah be used in template render
+      def initialize instance, *list
+        extend ApplicationHelper
+
+        @_source_object = instance
+
+        list.flatten.compact.each do |el|
+          el = el.to_s.classify+'Helper'
+          extend el.constantize
+        end
+
+        local_vars = instance.class == Hash ? instance : instance.instance_variables_hash
+
+        # locals overide globals
+        for k, v in local_vars
+          instance_variable_set("@#{k.to_s.sub('@','')}", v)
+        end
+
+        # helper.instance_exec &block if block
+      end
+
+      define_method(:current) { Lux.current }
+      define_method(:request) { Lux.current.request }
+      define_method(:params)  { Lux.current.params }
+      define_method(:nav)     { Lux.current.nav }
+      define_method(:get)     { |name| instance_variable_get('@%s' % name) }
+
+      def no_white_space
+        yield.gsub(/>\s+</,'><')
+      end
+
+      # = content :foo do ...            # define
+      # = content :foo? ? true : false   # ceheck existance
+      # = content :foo                   # get content
+      def content key
+        name = 'haml_content_%s' % key
+
+        if name.end_with?('?')
+          haz = !!Lux.current.var[name.sub(/\?$/, '')]
+          if block_given?
+            haz ? "#{yield}" : ''
+          else
+            haz
+          end
+        elsif block_given?
+          Lux.current.var[name] = "#{yield}"
+          nil
+        else
+          Lux.current.var[name]
+        end
+      end
+
+      def capture_proc
+        proc { |*args| "#{yield(*args)}" }
+      end
+
+      # renders just template but it is called
+      # = render :_link, link:link
+      # = render 'main/links/_link', link:link
+      def render name = nil, locals = {}
+        if !name
+          return InlineRenderProxy.new(self)
+        elsif name.is_array?
+          return name.map { |b| render(b) }.join("\n")
+        elsif name.respond_to?(:db_schema)
+          raise 'not supported'
+          path = Lux.current.var.root_template_path.split('/')[1]
+          table_name = name.class.name.tableize
+          locals[table_name.singularize.to_sym] = name
+          eval "@_#{table_name.singularize} = name"
+          name = "#{path}/#{table_name}/_#{table_name.singularize}"
+        elsif !name.to_s.start_with?('./')
+          template_path = Lux.current.var.root_template_path || './app/views'
+          name = Pathname.new(template_path).join(name.to_s).to_s
+          name = './app/views' + name if name.starts_with?('/')
+        end
+
+        for k, v in locals
+          instance_variable_set("@_#{k}", v)
+        end
+
+        if block_given?
+          name = "#{name}/layout" unless name.index('/')
+
+          Lux::Template.render(self, name) { yield() }
+        else
+          Lux::Template.render(self, name)
+        end
+      end
+
+      def cache name = nil, opts = {}, &block
+        if opts.class == Integer
+          opts = { ttl: opts }
+        elsif name.is_a?(Hash)
+          opts = name
+          name = ''
+        else
+          name = Lux.cache.generate_key(name)
+        end
+
+        opts[:ttl] ||= 1.hour
+        key = 'view:'+name+block.source_location.join(':')+Lux.config.deploy_timestamp.to_s
+        Lux.cache.fetch(key, opts) { yield }
+      end
+
+      # helper(:main).method
+      def helper *names
+        Lux::Template::Helper.new(self, *names)
+      end
+
+      def once id = nil
+        Lux.current.once("template-#{id || caller[0]}") do
+          block_given? ? yield : true
+        end
+      end
+
+      def flash
+        Lux.current.response.flash
+      end
+    end
+  end
+end
+

data/lib/lux/template/inline_render_proxy.rb

@@ -0,0 +1,31 @@
+# enables variable access as a method call to render helper
+# = render :_menu, foo: 123, bar: nil
+# render.foo # 123
+# render.bar ||= 456
+# render.bar # 456
+module Lux
+  class InlineRenderProxy
+    def initialize context, &block
+      @context = context
+      @block   = block
+    end
+
+    def method_missing name, value=nil
+      name = name.to_s
+
+      if name.sub!('=', '')
+        @context.instance_variable_set("@_#{name}", value)
+      end
+
+      @context.instance_variable_get("@_#{name}")
+    end
+  end
+
+  def [] name
+    @context.instance_variable_get("@_#{name}")
+  end
+
+  def []= name, value
+    @context.instance_variable_set("@_#{name}", value)
+  end
+end

data/lib/lux/template/lux_adapter.rb

@@ -0,0 +1,5 @@
+module Lux
+  def template
+    Lux::Template
+  end
+end