lux-fw 0.5.36 → 0.6.2

data/lib/lux/application/lib/nav.rb

@@ -1,104 +1,223 @@
 # experiment for different nav in rooter
 
-class Lux::Application::Nav
-  attr_accessor :path, :id, :format
-  attr_reader :original, :subdomain, :domain
-
-  # acepts path as a string
-  def initialize request
-    @path = request.path.split('/').slice(1, 100) || []
-    @original = @path.dup
-
-    @subdomain = request.host.split('.')
-    @domain    = @subdomain.pop(2).join('.')
-    @subdomain = @subdomain.join('.')
-    @domain    += ".#{@subdomain.pop}" if @domain.length < 6
-
-    set_format
-  end
-
-  def set_format
-    return unless @path.last
-    parts = @path.last.split('.')
-
-    if parts[1]
-      @format    = parts.pop.to_s.downcase.to_sym
-      @path.last = parts.join('.')
-    end
-  end
-
-  def active_shift
-    @active = @path.shift
-  end
-
-  def shift
-    return unless @path[0].present?
-
-    if block_given?
-      result = yield(@path[0]) || return
-
-      result
-    else
-      active_shift
-    end
-  end
-
-  # used to make admin.lvm.me/users to lvh.me/admin/users
-  def unshift name
-    @path.unshift name
-  end
-
-  def root sub_nav=nil
-    if block_given?
-      return unless @path[0]
-
-      # shift root in place if yields not nil
-      result = yield(@path[0]) || return
-      active_shift
-      result
-    else
-      sub_nav ? ('%s/%s' % [@path.first, sub_nav]) : @path.first
+module Lux
+  class Application
+    class Nav
+      attr_accessor :format
+      attr_reader :original, :domain, :subdomain, :querystring, :ids
+
+      # acepts path as a string
+      def initialize request
+        @path        = request.path.split('/').slice(1, 100) || []
+        @original    = @path.dup
+        @request     = request
+        @querystring = {}.to_hwia
+        @ids         = []
+        @shifted     = []
+
+        set_variables
+        set_domain request
+        set_format
+      end
+
+      def root
+        @path.first
+      end
+
+      def root= value
+        @path[0] = value
+      end
+
+      def shift
+        @path.shift.tap do |value|
+          @shifted.push value
+        end
+      end
+
+      # used to make admin.lvm.me/users to lvh.me/admin/users
+      def unshift name = nil
+        if name
+          @path.unshift name
+          @path = @path.flatten
+          name
+        else
+          @path.unshift @shifted.pop
+        end
+      end
+
+      # pop element of the path
+      def pop replace_with = nil
+        if block_given?
+          if result = yield(@path.last)
+            @path.pop
+            @path.unshift replace_with if replace_with
+            result
+          end
+        else
+          @path.shift
+        end
+      end
+
+      def last
+      #   if block_given?
+      #     # replace root in place if yields not nil
+      #     return unless @path.last.present?
+      #     result = yield(@path.last) || return
+      #     @path.pop
+      #     result
+      #   else
+          @path.last
+      #   end
+      end
+
+      # get Url object initialized with request.url - relative
+      # current.nav.url(:foo, 1).to_s # /path?foo=1
+      def url *args
+        if args.first
+          Url.current.qs(*args)
+        else
+          Url.current
+        end
+      end
+
+      def path *args
+        if args.first
+          # contruct path
+          # /upload_dialog/is_image:true/model:posts/id:2/field:image_url
+          # = nav.path :model, :id, :field -> /upload_dialog/model:posts/id:2/field:image_url
+          parts  = @original.select {|el| !el.include?(':') }
+          parts += args.map do |el|
+            if value = Lux.current.params[el]
+              [el, value].join(':')
+            end
+          end.compact
+          '/' + parts.join('/')
+        elsif block_given?
+          @path = @path.map { _1.gsub('-', '_') }
+        else
+          @path
+        end
+      end
+
+      def path= list
+        @path = list
+      end
+
+      # removes leading www.
+      # https://www.foo.bar/path -> https://foo.bar/path
+      def remove_www
+        url = Lux.current.request.url
+
+        if url.include?('://www.')
+          Lux.current.response.redirect_to url.sub('://www.', '://')
+        end
+      end
+
+      # nav.rename_domain 'localhost', 'lvh.me'
+      # http://localhost:3000/foo?bar=123 -> http://lvh.me:3000/foo?bar=123
+      def rename_domain from_domain, to_domain
+        if from_domain == @domain
+          url = Url.new Lux.current.request.url
+          Lux.current.response.redirect_to url.domain(to_domain).to_s
+        end
+      end
+
+      # http://tiger.lvh.me:3000/foo?bar=1 -> http://tiger.lvh.me:3000
+      def base
+        @base ||= Lux.current.request.url.split('/').first(3).join('/')
+      end
+
+      def to_s
+        @path.join('/').sub(/\/$/, '')
+      end
+
+      # accept only two strings locale
+      # nav.locale { _1.length == 2 ? _1 : nil }
+      def locale
+        if @locale
+          return @locale.to_s == '' ? nil : @locale
+        end
+
+        if @path[0].to_s.downcase =~ /^[a-z]{2}(-[a-z]{2})?$/
+          if @locale = yield(@path[0])
+            @path.shift
+          else
+            @locale = ''
+          end
+        end
+
+        @locale
+      end
+
+      def locale= name
+        @locale = name.present? ? name.to_s : nil
+      end
+
+      def id
+        @ids.last
+      end
+
+      # replace nav path with id, when mached (works with resourceful routes map 'controler')
+      # nav.path_id { _1.split('-').last.string_id rescue nil }
+      # /foo/test-cbjy/bar -> ['foo', :id, 'bar]
+      def path_id
+        @path = @path.map do |el|
+          if result = yield(el)
+            @ids.push result
+            :id
+          else
+            el
+          end
+        end
+
+        @ids.last
+      end
+
+      private
+
+      def set_variables
+        # convert /foo/bar:baz to /foo?bar=baz
+        while @path.last&.include?(':')
+          key, val = @path.pop.split(':', 2)
+          @querystring[key] = val
+          Lux.current.params[key.to_sym] ||= val
+        end
+      end
+
+      def set_domain request
+        begin
+          # NoMethodError
+          # Message undefined method `start_with?' for nil:NilClass
+          # gems/rack-2.2.4/lib/rack/request.rb:567:in `wrap_ipv6'
+          parts = request.host.to_s.split('.')
+        rescue NoMethodError
+          raise Lux::Error.bad_request('Host name error')
+        end
+
+        if parts.last.is_numeric?
+          @domain = request.host
+        else
+          count = 2
+          count = 1 if parts.last == 'localhost'
+          count = 3 if parts.last(2).join('.') == 5 # foo.co.uk
+
+          @domain    = parts.pop(count).join('.')
+          @domain    += ".#{parts.pop}" if @domain.length < 6
+          @subdomain = parts.join('.')
+        end
+      end
+
+      def set_format
+        return unless @path.last
+        parts = @path.last.split('.')
+
+        if parts[1]
+          @format    = parts.pop.to_s.downcase.to_sym
+          @path.last = parts.join('.')
+        end
+
+        @path.shift if @path[0] == ''
+      end
     end
   end
-
-  def root= value
-    @path[0] = value
-  end
-
-  def first
-    if block_given?
-      # shift first in place if yields not nil
-      return unless @path[1].present?
-      result = yield(@path[1]) || return
-      @path.slice!(1,1)
-      result
-    else
-      @path[1]
-    end
-  end
-
-  def last
-    if block_given?
-      # replace root in place if yields not nil
-      return unless @path.last.present?
-      result = yield(@path.last) || return
-      @path.pop
-      result
-    else
-      @path.last
-    end
-  end
-
-  def second
-    @path[2]
-  end
-
-  def active
-    @active
-  end
-
-  def to_s
-    @path.join('/').sub(/\/$/, '')
-  end
-
 end

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

@@ -1,69 +1,49 @@
-# 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.app.render('/admin') -> { status: 403, ... }
-# Lux.app.render('/admin', session: { user_id: User.is_admin.first.id })
-# {
-#   time: '1ms'
-#   status: 200,
-#   headers: {...},
-#   session: {...},
-#   body: '<html> ...'
-# }.h
-
-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) }
-    # in_opts[:session] = nil unless Hash == in_opts[:session].class
-
-    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
+# renders pages without server
+
+module Lux
+  class Application
+    module Render
+      extend self
+
+      # Alternative was to call render action
+      # `Lux.app.new(path, full_opts).render.headers`
+      # `Lux.render.post(path, params, rest_of_opts).headers`
+      # `Lux.render.get('/search', params: { q: 'london' }, session: {user_id: 1} }).body`
+      %i(get post delete patch put).each do |req_method|
+        define_method req_method do |path, opts={}|
+          Lux.app.new(path, opts.merge(method: req_method)).render
+        end
+      end
+
+      # Render controller action without routes, pass a block to yield before action call.
+      # `Lux.render.controller('main/cities#foo').body`
+      # `Lux.render.controller('main/cities#foo') { @city = City.last_updated }.body`
+      def controller klass, &block
+        klass, action = klass.split('#')
+
+        klass = (klass+'Controller').classify.constantize if klass.is_a?(String)
+        c = klass.new
+        c.instance_exec &block if block
+        c.send action
+
+        Lux.current.response
+      end
+
+      # Lux.render.controller('main/cities#bar') { @city = City.last_updated }.body
+      def template *args
+        Lux::Template.render *args
+      end
+
+      # Lux.render.cell(:user, self, { product: @bar }).foo
+      # Lux.render.cell(:user, self).foo
+      # Lux.render.cell(:user, { product: @bar }).foo
+      # Lux.render.cell(:user).foo @arg
+      def cell name, *args
+        opts    = args.last.is_a?(Hash) ? args.pop : {}
+        context = args.shift
+        Lux::ViewCell.get(name, context, opts)
+      end
     end
-
-    current = Lux::Current.new(env)
-    current.session.merge!(in_opts[:session]) if in_opts[:session]
-
-    app = new current
-
-    return app.instance_exec &block if block_given?
-
-    response = app.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: current.session.hash,
-      body: body
-    }.h
   end
-end
+end
+

data/lib/lux/application/lib/routes.rb

@@ -0,0 +1,242 @@
+module Lux
+  class Application
+    module Routes
+      # generate get, get?, post, post? ...
+      # get {}
+      # get foo: 'main/bar', only: [:show], except: [:index]
+      %w{get head post delete put patch}.each do |m|
+        define_method('%s?' % m) do |*args, &block|
+          cm = current.request.request_method
+          cm = 'GET' if cm == 'HEAD'
+          return unless cm == m.upcase
+
+          if block
+            # get? { ... }
+            block.call
+          elsif args.first
+            # post api: 'api#call'
+            map *args
+          else
+            true
+          end
+        end
+      end
+
+      # Matches if there is not root in nav
+      # Example calls MainController.action(:index) if in root
+      # ```
+      # root 'main#index'
+      # ```
+      def root target
+        call target unless nav.root
+      end
+
+      # standard route match
+      # match '/:city/people', Main::PeopleController
+      def match base, target
+        base = base.split('/').slice(1, 100)
+
+        base.each_with_index do |el, i|
+          if el[0,1] == ':'
+            params[el.sub(':','').to_sym] = nav.path[i]
+          else
+            return unless el == nav.path[i]
+          end
+        end
+
+        call target
+      end
+
+      # Matches given subdomain name
+      def subdomain name
+        return unless nav.subdomain == name.to_s
+        yield
+        Lux.error.not_found 'Subdomain "%s" matched but nothing called' % name
+      end
+
+      # Main routing object, maps path part to target
+      # if path part is positively matched with `test?` method, target is called with `call` method
+      # ```
+      # map api: ApiController
+      # map api: 'api'
+      # map [:api, ApiController]
+      # map 'main/root' do
+      # map [:login, :signup] => 'main/root'
+      # map :city do
+      # map 'city' do
+      #   map :about
+      # end
+      # ```
+      def map route_object = nil, target = nil &block
+        return @magic unless route_object
+        return if response.body?
+
+        route_object = [route_object, target] if target
+
+        if block_given?
+          # map 'admin' do ...
+          if test?(route_object)
+            yield nav.root
+            nav.unshift
+          end
+
+          return
+        end
+
+        klass  = nil
+        route  = nil
+        action = nil
+        opts   = {}
+
+        case route_object
+        when String
+          # map 'root#call'
+          nav.shift
+          catch(:done) { call route_object }
+        when Hash
+          route  = route_object.keys.first
+          klass  = route_object.values.first
+
+          if route_object.keys.length > 1
+            opts = route_object.dup
+            opts.delete route
+          end
+
+          if route.class == Array
+            # map [:foo, :bar] => 'root'
+            for route_action in route
+              if test?(route_action)
+                call klass, route_action
+              end
+            end
+
+            return
+          elsif route.is_a?(String) && route[0,1] == '/'
+            # map '/skils/:skill' => 'main/skills#show'
+            return match route, klass
+          end
+        when Array
+          # map [:foo, 'main/root']
+          route, klass, opts = *route_object
+        else
+          Lux.error 'Unsupported route type "%s"' % route_object.class
+        end
+
+        test?(route) ? call(klass, nil, opts) : nil
+      end
+
+      # Calls target action in a controller, if no action is given, defaults to :call
+      # ```
+      # call :api_router
+      # call { 'string' }
+      # call proc { [400, {}, 'error: ...'] }
+      # call [200, {}, ['ok']]
+      # call Main::UsersController
+      # call Main::UsersController, :index
+      # call [Main::UsersController, :index]
+      # call 'main/orgs'      -> index, show
+      # call 'main/orgs#show' -> show
+      # call 'main/orgs?list' -> list_index, list_show # provies namespace in controller
+      # ```
+      def call object=nil, action=nil, opts=nil, &block
+        # log original app caller
+        root      = Lux.root.join('app/').to_s
+        sources   = caller.select { |it| it.include?(root) }.map { |it| 'app/' + it.sub(root, '').split(':in').first }
+        action    = action.gsub('-', '_').to_sym if action && action.is_a?(String)
+        namespace = nil
+        object  ||= block if block_given?
+
+        Lux.log { ' Routed from: %s' % sources.join(' ') } if sources.first
+
+        case object
+        when Symbol
+          return send(object)
+        when Hash
+          object = [object.keys.first, object.values.first]
+        when String
+          if object.include?('#')
+            object, action = object.split('#')
+          else
+            action = if nav.root == :id
+              nav.path[1] || :show
+            else
+              nav.path[0] || :index
+            end
+          end
+        when Array
+          if object[0].class == Integer && object[1].class == Hash
+            # [200, {}, 'ok']
+            for key, value in object[1]
+              response.header key, value
+            end
+
+            response.status object[0]
+            response.body object[2].is_a?(Array) ? object[2].first : object[2]
+          else
+            object, action = object
+          end
+        when Proc
+          case data = object.call
+          when Array
+            response.status = data.first
+            response.body data[2].is_a?(Array) ? data[2][0] : data[2]
+          else
+            response.body data
+          end
+        end
+
+        if object.is_a?(String)
+          object = ('%s_controller' % object).classify.constantize
+        end
+
+        if [Module, Class].include?(object.class) && object.respond_to?(:call)
+          response.rack object
+        end
+
+        if object.respond_to?(:source_location)
+          current.files_in_use object.source_location
+        end
+
+        opts   ||= {}
+        action ||= nav.path.last || :index
+
+        if opts[:only] && !opts[:only].include?(action.to_sym)
+          Lux.error.not_found Lux.env.show_errors? ? "Action :#{action} not allowed on #{object}, allowed are: #{opts[:only]}" : nil
+        end
+
+        if opts[:except] && opts[:except].include?(action.to_sym)
+          Lux.error.not_found Lux.env.show_errors? ? "Action :#{action} not allowed on #{object}, forbidden are: #{opts[:except]}" : nil
+        end
+
+        if object.respond_to?(:action)
+          object.action action.to_sym
+        end
+
+        throw :done if response.body?
+      end
+
+      # Tests current root against the string to get a mach.
+      # Used by map function
+      def test? route
+        root = nav.root.to_s
+
+        ok = case route
+        when String
+          root == route.sub(/^\//,'')
+        when Symbol
+          route.to_s == root
+        when Regexp
+          !!(route =~ root)
+        when Array
+          !!route.map(&:to_s).include?(root)
+        else
+          false
+        end
+
+        nav.shift if ok
+      end
+    end
+  end
+end
+
+