lux-fw 0.1.35 → 0.2.1

data/lib/lux/{controller → application}/lib/nav.rb

@@ -1,8 +1,7 @@
 # experiment for different nav in rooter
 
-class Lux::Controller::Nav
-
-  attr_reader :root, :path, :id, :full, :locale, :subdomain, :domain
+class Lux::Application::Nav
+  attr_reader :path, :subdomain, :domain, :id
 
   # acepts path as a string
   def initialize request
@@ -12,32 +11,31 @@ class Lux::Controller::Nav
     @subdomain = request.host.split('.')
     @domain    = @subdomain.pop(2).join('.')
     @domain    += ".#{@subdomain.pop}" if @domain.length < 6
-
-    build_full
   end
 
-  def build_full
+  def full
     @full = '/%s/%s' % [@root, @path.join('/')]
+    @full = @full.sub(/\/$/, '')
   end
 
   def shift_to_root
     @root.tap do
       @root = @path.shift.to_s.gsub('-', '_')
-      build_full
     end
+
+    @root = nil if @root.blank?
+
+    @root
+  end
+
+  def root sub_nav=nil
+    sub_nav ? ('%s/%s' % [@root, sub_nav]) : @root
   end
 
   # used to make admin.lvm.me/users to lvh.me/admin/users
   def unshift name
     @path.unshift @root
     @root = name
-    build_full
-  end
-
-  def parse_locale
-    return false unless Locale.all.include?(@root)
-    Locale.current = shift_to_root
-    true
   end
 
   def shift
@@ -68,14 +66,13 @@ class Lux::Controller::Nav
     @full
   end
 
-  # if sets @id to whatever function returns
-  # page.nav.id! { |id| StringBase.extract id }
-  def id! &block
-    @block = block if block
+  def id
+    if first && block_given?
+      if @id = yield(first)
+        shift
+      end
+    end
 
-    return unless first
-    @id = @block.call first
-    shift if @id
     @id
   end
 end

data/lib/lux/application/lib/plugs.rb

@@ -0,0 +1,10 @@
+class Lux::Application
+
+  def lux_static_files_plug
+    file = Lux::Current::StaticFile.new(Lux.current.request.path)
+    return false unless file.is_static_file?
+    file.deliver
+    true
+  end
+
+end

data/lib/lux/application/lib/render.rb

@@ -0,0 +1,58 @@
+# 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
+
+Lux::Application.class_eval do
+  def self.render path='/mock', 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::Current.new(env)
+    Lux.current.session.merge!(in_opts[:session]) if in_opts[:session]
+
+    if block_given?
+      return Lux.app.new.instance_exec &block
+    end
+
+    response = Lux.current.response.render
+
+    body = response[2].join('')
+    body = JSON.parse body if response[1]['content-type'].index('/json')
+
+    {
+      time: response[1]['x-lux-speed'],
+      status: response[0],
+      headers: response[1],
+      session: Lux.current.session,
+      body: body
+    }.h
+  end
+end

data/lib/lux/application/lib/route_test.rb

@@ -0,0 +1,64 @@
+# called by Lux::Application to test route matching
+class Lux::Application::RouteTest
+  LUX_PRINT_ROUTES = !!ENV['LUX_PRINT_ROUTES'] unless defined?(LUX_PRINT_ROUTES)
+
+  def initialize controller
+    @controller = controller
+  end
+
+  def current
+    Lux.current
+  end
+
+  def action route_object, opts={}
+    if route_object.class == Hash
+      route_test = route_object.keys.first
+      route_to   = route_object.values.first
+    else
+      route_test = route_object
+      route_to   = opts[:to] || route_object
+    end
+
+    puts '/%s => %s#%s' % [route_test.to_s.ljust(20), @controller.route_target, route_to] if LUX_PRINT_ROUTES
+
+    if test? route_test
+      @controller.call @controller.route_target, route_to
+    end
+  end
+  alias :map :action
+
+  def call route
+    if test? route
+      @controller.call @controller.route_target
+    end
+  end
+
+  # calls base index if root
+  def root
+    @controller.call @controller.route_target unless current.nav.root
+  end
+
+  def test? route
+    case route
+      when String
+        current.request.path.starts_with?(route)
+      when Symbol
+        route.to_s == current.nav.root
+      when Regexp
+        !!(route =~ current.nav.root)
+      when Array
+        !!route.map(&:to_s).include?(current.nav.root)
+      else
+        raise 'Route type %s is not supported' % route.class
+    end
+  end
+
+  def print_route route, action=nil
+    return unless LUX_PRINT_ROUTES
+
+    target = @controller.route_target.to_s
+    target += '#%s' % action if action
+
+    puts '/%s => %s' % [route.to_s.ljust(20), target]
+  end
+end

data/lib/lux/cache/cache.rb

@@ -3,19 +3,14 @@
 module Lux::Cache
   extend self
 
+  # Lux::Cache.sever = :ram
   def server= obj
+    obj = "Lux::Cache::#{obj.to_s.classify}Cache".constantize if obj.class == Symbol
     @@server = obj
   end
 
-  # cache data in current thread
-  def thread key
-    data = Lux.thread[:cache][key]
-    return data if data
-    Lux.thread[:cache][key] = yield
-  end
-
   def read key
-    return nil if (Lux.page.no_cache? rescue false)
+    return nil if (Lux.current.no_cache? rescue false)
     @@server.get(key)
   end
   alias :get :read
@@ -36,20 +31,22 @@ module Lux::Cache
   end
 
   def fetch key, opts={}
-    opts = { ttl: opts } unless opts.is_a?(Hash)
-    opts = opts.to_opts!(:ttl, :log, :force)
+    opts     = { ttl: opts } unless opts.is_a?(Hash)
+    opts     = opts.to_opts!(:ttl, :force, :log)
 
     opts.ttl     = opts.ttl.to_i if opts.ttl
-    opts.log   ||= true if opts.log.nil?
-    opts.force ||= true if opts.force.nil?
+    opts.log   ||= Lux.config(:log_to_stdout) unless opts.log.class == FalseClass
+    opts.force ||= Lux.current.try(:no_cache?)   unless opts.force.class == FalseClass
 
-    @@server.delete key if Lux.page && opts.force && Lux.page.no_cache?
+    @@server.delete key if opts.force
 
     Lux.log " Cache.fetch.get #{key} (ttl: #{opts.ttl.or(:nil)})".green if opts.log
 
     data = @@server.fetch key, opts.ttl do
-      data = yield
-      Lux.log " Cache.fetch.SET #{key} len:#{data.to_s.length}" if opts.log
+      speed = Lux.speed { data = yield }
+
+      Lux.log " Cache.fetch.SET #{key} len:#{data.to_s.length} (#{speed})".red if opts.log
+
       data
     end
 
@@ -63,7 +60,10 @@ module Lux::Cache
 
   def generate_key *data
     keys = []
+
     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)
@@ -72,7 +72,18 @@ module Lux::Cache
         keys.push el.to_s
       end
     end
+
     key = keys.join('-')
-    key.length < 30 ? key : Crypt.md5(key)
+    Crypt.sha1(key)
+  end
+
+  def []= key, value
+    @@server.set key.to_s, value
+    value
   end
+
+  def [] key
+    @@server.get key.to_s
+  end
+
 end

data/lib/lux/cell/cell.rb

@@ -14,18 +14,18 @@ class Lux::Cell
   ClassAttributes.define self, :helper
 
   # before and after any action filter, ignored in cells, after is called just before render
-  BeforeAndAfter.define self, :before, :before_action, :before_render, :after
+  ClassCallbacks.define self, :before, :before_action, :before_render, :after
 
   class << self
     # class call method, should not be overridden
     def call
-      Lux.page.files_in_use.push "app/cells/#{self.to_s.underscore}.rb"
+      Lux.current.files_in_use.push "app/cells/#{self.to_s.underscore}.rb"
 
       cell = new
       cell.filter :before
       cell.call
 
-      return if Lux.page.body
+      return if Lux.current.response.body
 
       # we want to exec filter after the call
       cell.filter :before_action
@@ -34,8 +34,7 @@ class Lux::Cell
     # create mock function, to enable template rendering
     # mock :index, :login
     def mock *args
-      for el in args
-        # class_eval %[def #{el}(*args); true; end]
+      args.each do |el|
         define_method el do
           true
         end
@@ -43,19 +42,8 @@ class Lux::Cell
     end
 
     # simple shortcut allows direct call to action, bypasing call
-    def action name, object=nil
-      object.present? ? new.action(name, object) : new.action(name)
-    end
-
-    # for use in helpers, mostly
-    # renders only cell without layout
-    # = cell :tag_list, object
-    def cell name, *args
-      c = new
-      c.instance_variable_set '@cell_action', name
-      c.instance_variable_set '@no_render', true
-      c.send name, *args
-      c.render_part
+    def action *args
+      new.action(*args)
     end
   end
 
@@ -66,7 +54,7 @@ class Lux::Cell
   def initialize
     # before and after should be exected only once
     @executed_filters = {}
-    @base_template = self.class.to_s.index('::') ? self.class.to_s.sub(/Cell$/,'').underscore : self.class.to_s.sub(/Cell$/,'').downcase
+    @base_template = self.class.to_s.include?('::') ? self.class.to_s.sub(/Cell$/,'').underscore : self.class.to_s.sub(/Cell$/,'').downcase
   end
 
   # default call method, should be overitten
@@ -76,11 +64,17 @@ class Lux::Cell
     action(:index)
   end
 
+  # execute before and after filters, only once
   def filter fiter_name
+    # move this to ClassCallbacks class?
     return if @executed_filters[fiter_name]
     @executed_filters[fiter_name] = true
 
-    BeforeAndAfter.execute(self, fiter_name)
+    ClassCallbacks.execute(self, fiter_name)
+  end
+
+  def cache *args, &block
+    Lux.cache.fetch *args, &block
   end
 
   # action(:show, 2)
@@ -89,17 +83,17 @@ class Lux::Cell
     raise ArgumentError.new('Cell action called with blank action name argument') if method_name.blank?
 
     # maybe before filter rendered page
-    return if Lux.page.body
+    return if response.body
 
     method_name = method_name.to_s.gsub('-', '_').gsub(/[^\w]/, '')
 
     Lux.log " #{self.class.to_s}(:#{method_name})".light_blue
-    Lux.page.files_in_use.push "app/cells/#{self.class.to_s.underscore}.rb"
+    Lux.current.files_in_use.push "app/cells/#{self.class.to_s.underscore}.rb"
 
     @cell_action = method_name
 
     unless respond_to? method_name
-      raise NotFoundError.new('Method %s not found' % method_name) unless Lux.verbose?
+      raise NotFoundError.new('Method %s not found' % method_name) unless Lux.config(:show_server_errors)
 
       list = methods - Lux::Cell.instance_methods
       err = [%[No instance method "#{method_name}" found in class "#{self.class.to_s}"]]
@@ -109,15 +103,15 @@ class Lux::Cell
     end
 
     filter :before
-    return if Lux.page.body
+    return if response.body
 
     filter :before_action
-    return if Lux.page.body
+    return if response.body
 
     send method_name, *args
     filter :after
 
-    return if Lux.page.body
+    return if response.body
     render
   end
 
@@ -127,7 +121,7 @@ class Lux::Cell
   # render :profile,  name:'Dux'
   # render text: 'ok'
   def render name=nil, opts={}
-    return if Lux.page.body
+    return if response.body
     return if @no_render
 
     filter :before_render
@@ -139,8 +133,9 @@ class Lux::Cell
 
     opts[:template] = name if name
 
-    render_resolve_body(opts)
-    Lux.cache.set(opts[:cache], Lux.page.body) if opts[:cache]
+    render_resolve_body opts
+
+    Lux.cache.set(opts[:cache], response.body) if opts[:cache]
   end
 
   # renders template to string
@@ -162,18 +157,16 @@ class Lux::Cell
     def render_resolve_body opts
       # resolve basic types
       if opts[:text]
-        Lux.page.content_type = 'text/plain'
-        return Lux.page.body(opts[:text])
+        response.content_type = 'text/plain'
+        return response.body(opts[:text])
       elsif opts[:html]
-        Lux.page.content_type = 'text/html'
-        return Lux.page.body(opts[:html])
+        response.content_type = 'text/html'
+        return response.body(opts[:html])
       elsif opts[:json]
-        Lux.page.content_type = 'application/json'
-        return Lux.page.body(opts[:json])
+        response.content_type = 'application/json'
+        return response.body(opts[:json])
       end
 
-      ivh = instance_variables_hash
-
       # resolve page data, without template
       page_data = opts[:data] || Proc.new do
         if template = opts.delete(:template)
@@ -183,15 +176,17 @@ class Lux::Cell
           template = "#{@base_template}/#{@cell_action}"
         end
 
-        Lux::Template.render_part(template, ivh, self.class.helper)
+        Lux::Template.render_part(template, helper)
       end.call
 
       # resolve data with layout
       layout = opts.delete(:layout)
       layout = nil if layout.class == TrueClass
       layout = false if @layout.class == FalseClass
+
       if layout.class != FalseClass
-        layout_define = self.class.layout
+        layout_define = layout || self.class.layout
+
         layout = case layout_define
           when String
             layout = layout_define
@@ -203,47 +198,64 @@ class Lux::Cell
             "#{@base_template.split('/')[0]}/layout"
         end
 
-        page_data = Lux::Template.new(layout, instance_variables_hash, self.class.helper).render_part do
+        page_data = Lux::Template.new(layout, helper).render_part do
           page_data
         end
       end
 
-      Lux.page.body(page_data) unless opts[:set_page_body].is_false?
+      response.body(page_data) unless opts[:set_page_body].is_false?
+
       page_data
     end
 
-    # helper functions
-    def page
-      Lux.page
+    def etag *args
+      response.etag *args
     end
 
-    def params
-      Lux.page.params
+    def halt status, desc=nil
+      response.status = status
+      response.body   = desc || "Hatlt code #{status}"
+
+      throw :done
     end
 
-    def nav
-      Lux.page.nav
+    # helper functions
+    def current
+      Lux.current
     end
 
     def request
-      Lux.page.request
+      Lux.current.request
+    end
+
+    def response
+      Lux.current.response
+    end
+
+    def params
+      Lux.current.params
+    end
+
+    def nav
+      Lux.current.nav
     end
 
     def redirect where, flash={}
-      Lux.page.redirect where, flash
+      Lux.current.redirect where, flash
     end
 
     def session
-      Lux.page.session
+      Lux.current.session
     end
 
     def namespace
       @base_template.split('/')[0].to_sym
     end
 
-    def helper(ns=nil)
-      Lux::Helper.for(ns || namespace)
+    def helper ns=nil
+      Lux::Helper.new self, :html, self.class.helper, ns
     end
-
 end
 
+ApplicationCell = Class.new Lux::Cell
+