nephos-server 0.6.4 → 0.6.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a7a62dad08b09b531aab62f3e9800f65ec7e849d
-  data.tar.gz: ffd36f823891ca5141950551e6e3de7984f8b8d4
+  metadata.gz: d8bb785df5db4f9f8b7a8e4821582700962d0fe4
+  data.tar.gz: f681de7959a63e202b03f80caf0d730142eaef0d
 SHA512:
-  metadata.gz: 58a3d571167c75ccd6ebc97bc56fd4ec44c766b1dccfe3748746b467e44db39d3fe3ea3cd8588fdb3b53f92f692f0fd5b28fafe87537e4e4b7910637a84e90df
-  data.tar.gz: bbf86241ed2a7671d81b84cdea1c32960ef0e698ff29a0b37c246a2f7d0940b0d12ad13f14f5d1a7d606a53c55da93b44bf85ed6f9bb5a52ea0b7235c2882540
+  metadata.gz: ec1e2f6a1d7afe305c39b7664787a31806a60d4f0bc9ed08a1add184f77408b87d09eeb10dbb913662f19ea992a2e3af993584648b0e138f95226c34514f6ac4
+  data.tar.gz: 41f1943b9e313ee1a45e998565e6628e118ba95fcf434cc591c8f993dd633a15b070b076b0fb2cfed1bcde47d059d56b89a284d8c1923785dc6e04045f4a4432

data/CHANGELOG

@@ -1,3 +1,9 @@
+v0.6.5
+	* Improve routing helpers (optional url parameter)
+	* Add new functional tests (router)
+	* Add extension for url (.html, ...)
+	* Add improved router helper (simple destination, alias)
+
 v0.6.4
 	* Fix application generator (replace in the gemfile nephos-server by nephos)
         * Improve guides (more doc, corrections, update)

data/DOCUMENTATION/API_RENDER.md

@@ -1,14 +1,18 @@
 # Render API
 
-## Understand the API
+## What is the Render API ?
 The render API is a simple system to allows you to render HTTP responses to a client.
+It is a simple way to render data to the user and choose it's type.
+
 The API allows you to customize differents parts of the response:
 
 - HTTP status
 - HTTP Content-Type
 - Content
 
-The API use the returns of the Controllers methods to build the HTTP responses.
+Based on the returns of your Controller's methods, it will render to the user
+a HTTP response.
+You can actually returns HTML, JSON, or PLAIN text, and custom formats if needed.
 
 
 ## Use the API
@@ -20,14 +24,13 @@ It must contain a class, inheriting from ``Nephos::Controller``.
 Each public method **can** be an entry point, defined in the ``routes.rb`` file.
 [Routing documentation](GUIDE_ROUTING.md).
 
-In the controller, you can use few helpers,
-like the method ``params()`` and ``cookies``
+Theses methods, described as "entry points" by your routing rules, must **return** a ``Hash``.
+It's format will be described in the following parts.
 
-The methods used as entry point must return a ``Hash`` described in the following lines.
-It may optionnaly be an ``Integer``, to return only a status, or ``:empty``.
+*Notes: The return may optionnaly be an ``Integer``, to return only a status, or ``:empty``.*
 
-## Options
-The returns of a Controller method can include the following keys:
+## Returned hash
+The return of a Controller method can include the following keys:
 
 - :plain
 - :html
@@ -52,7 +55,7 @@ class MyController < Nephos::Controller
 end
 ```
 
-The following sections will describe how each key works and modify the HTTP response.
+The following sections will describe how each key works, and modify the HTTP response.
 
 ### Content
 The ``:content`` key must be associated with a ``String`` (or ``Hash`` is json).

data/DOCUMENTATION/GUIDE_CONTROLLER.md

@@ -5,28 +5,48 @@
 ### Cookies
 You can set cookies and get them via ``cookies`` in the body of any controller.
 
+Example:
+```ruby
+    cookies["a"] = "b" # add a cookie named "a"
+    cookies.delete("b") # remove a cookie named "b"
+```
+
 ### Params
 You can access to the parameters (defined by http or via the URI, based on your
 routing rules).
 They are accessible via ``params`` in the body of every controller.
 
+Example:
+```ruby
+    params[:id] # access to the :id value, for exemple in the url /show/:id
+```
+
+### Requested format
+You can request a format by adding a ``.ext`` to the url you request.
+This format is accessible via the ``format`` method. (alias for ``extension``)
+
+It is also provided few helpers ``html?`` ``json?`` ``plain?``
+
+
 ### Hooks
-You can define hooks, which are some methods, called every times, before or
-after a call to a routed method. There is 2 kinds of hook actually:
+
+A hook is a method, triggered automatically after an action.
+
+Actually, NephosServer allows you to create 2 kinds of triggers for your hooks:
 
 - after_action
 - before_action
 
-Each of them will be called juste before or after calling the method requested.
-It means that the cookies are not saved yet (so you can change them, etc.)
+Your hooks will be called just before/after calling the method requested.
+It means that the cookies are not saved yet (so you can change them, etc.) for example.
 
 The hooks are defined by calling the methods ``after_action`` or
 ``before_action``, out of a method, usually on the top of the controller.
 
-Hooks take 1 or 2 arguments.
-- The first is the name of the method to call.
-- The second, **optional**, is a hash, containing ``:only`` or ``:except``
-  keys, associated to an Array or Symbol or one Symbol. Each symbol represents
+Triggers take 1 or 2 arguments.
+- The first is the name of the Hook to use. **This is a required argument**.
+- The second **is optional**. It should be a hash, containing ``:only`` or ``:except``
+  keys, associated to an Array of Symbols, or one Symbol. Each symbol represents
   a method triggering the hook.
 
 **Note: If there is no 2sd argument, then the hook is triggered every times.**

data/DOCUMENTATION/GUIDE_GENERATOR.md

@@ -2,7 +2,7 @@
 
 The ``ngenerator`` is a lite application designed to make easier the application management.
 
-Actually, it allows you to create new application and controller.
+Actually, it allows you to create new application, controller, or route.
 
 ## Usage
 

data/DOCUMENTATION/GUIDE_ROUTER.md

@@ -1,3 +1,4 @@
+
 # Routing Guide
 
 ### How the routes are inputed by the client ?
@@ -41,6 +42,13 @@ As example, yuo can write:
 add_route "GET", url: "/tmp", controller: "MyController", method: "tmp"
 ```
 
+**Note: if you are as lazy as me, you also can specifie the url out of the hash (option).
+It can be done by putting the url as second argument, like in the following example.
+This note is also valid for the next helpers (get, post, put)**
+```ruby
+add_route "GET", "/tmp", controller: "MyController", method: "tmp"
+```
+
 ### get post put
 Theses 3 helpers allows you to use ``add_route`` without the first argument.
 
@@ -86,6 +94,17 @@ resource "static" do
 end
 ```
 
+## Alias
+You can create many routes to the same entry point. Each of theses rules can be
+specified simply by placing an Array of String instead of a simple String in the
+hash passed to the helper (get, ... , add_route).
+Example:
+```ruby
+get url: ["/", "/index"], controller: "UserController", method: "show" # / and /index
+```
+
 ## Notes
 
 * When a request is done, duplicate / are not counted. So, ``/resource/id`` is equivalent to ``////resource//id`` etc.
+* It is possible, by default, to add a postfixed extension (like .html) to your rules. It is accessible via the controller (``extension`` method). It can be disabled by adding the option ``postfix: false``
+* You can replace the both keys ``:controller`` and ``:method`` by ``:to``, which has to be associated with a string like ``Controller#method``

data/README.md

@@ -100,6 +100,7 @@ put url: "/rm/:url", controller: "MainController", method: "rm_url"   # /rm with
 resource "infos" do
   get url: "/", controller: "MainController", method: "root" # generate /infos
   get url: "/about", controller: "MainController", method: "root" # generate /infos/about
+  get url: "/notice", to: "MainController#notice" # generate /infos/notice
 end
 ```
 
@@ -107,9 +108,7 @@ end
 # Developers: Roadmap
 
 ## TODO v0.6
-- Alias for routing
 - functionnal tests
-- extension for urls (optional .xxx, with controller effect)
 
 ## TODO v0.7
 - feature to change HTTP header from controller

data/Rakefile

@@ -1,5 +1,7 @@
 #encoding: utf-8
 
+require 'colorize'
+
 task :default => [:test]
 
 task :test do
@@ -10,11 +12,15 @@ namespace :test do
 
   desc "Unitary tests. Fasts and on the sources."
   task :test do
+    puts
     ruby "test/test.rb"
   end
 
   desc "Functional tests. Slow, test real the features under real conditions of usage."
   task :functional do
+    puts "!!! Important !!!".yellow
+    puts "You have to access to internet to test the generator.".yellow
+    puts
     ruby "test/functional.rb"
   end
 end

data/lib/nephos-server/basic_errors.rb

@@ -1,6 +1,7 @@
 class RoutingError < StandardError; end
 class InvalidRoute < RoutingError; end
 class InvalidRouteUrl < InvalidRoute; end
+class InvalidRouteTo < InvalidRoute; end
 class InvalidRouteController < InvalidRoute; end
 class InvalidRouteMethod < InvalidRoute; end
 

data/lib/nephos-server/controller.rb

@@ -6,11 +6,13 @@ module Nephos
   # and the parameters.
   class Controller
 
-    attr_reader :req, :callpath, :params, :cookies
+    attr_reader :req, :callpath, :params, :cookies, :extension
+    alias :format :extension
 
     # @param env [Hash] env extracted from the http request
     # @param parsed [Hash] pre-parsed env with parameters, ...
-    def initialize req, callpath
+    # @param extension [String] extension ".json", ".html", ...
+    def initialize req, callpath, extension=nil
       raise ArgumentError, "req must be a Rack::Request" unless req.is_a? Rack::Request
       raise ArgumentError, "call must be a Hash" unless callpath.is_a? Hash
       @req= req
@@ -24,6 +26,18 @@ module Nephos
 
       @params = Params.new(@params)
       @cookies = Params.new(@req.cookies)
+
+      @extension = extension.to_s.split(".").last
+    end
+
+    def html?
+      %w(htm html xhtml).include? extension
+    end
+    def json?
+      %w(json).include? extension
+    end
+    def plain?
+      %w(txt raw).include? extension
     end
 
     @@before_action = {:'*' =>  []}

data/lib/nephos-server/router/helpers.rb

@@ -4,6 +4,9 @@ def route_prefix
 end
 
 # @param verb [String] has to be a valid http verb, so a string uppercase
+# @param url [String] if an url is provided, then it will be put in the hash
+#   to have the same behavior as if it was specified in the what hash
+#   \\{url: URL}
 # @param what [Hash] has to contain the following keys:
 #   - :url
 #   - :controller
@@ -14,27 +17,35 @@ end
 # if the client request match with the verb and the url provided.
 #
 # Checkout the documentation about the parameters and API for more informations
-def add_route(verb, what)
+def add_route(verb, url=nil, what)
   raise InvalidRoute, "what must be a hash" unless what.is_a? Hash
-  what[:url] = File.expand_path File.join(route_prefix, what[:url])
-  Nephos::Router.check!(what)
-  Nephos::Router.add_params!(what)
-  Nephos::Router.add(what, verb)
+  what[:url] ||= url
+  Array(what[:url]).each do |url|
+    route = what.dup
+    route[:url] = url
+    route[:url] = File.expand_path File.join(route_prefix, route[:url])
+    Nephos::Router.check!(route)
+    Nephos::Router.add_params!(route)
+    Nephos::Router.add(route, verb)
+  end
 end
 
+# @param url [String] see {#add_route}
 # @param what [Hash] see {#add_route}
-def get what
-  add_route "GET", what
+def get url=nil, what
+  add_route "GET", url, what
 end
 
+# @param url [String] see {#add_route}
 # @param what [Hash] see {#add_route}
-def post what
-  add_route "POST", what
+def post url=nil, what
+  add_route "POST", url, what
 end
 
+# @param url [String] see {#add_route}
 # @param what [Hash] see {#add_route}
-def put what
-  add_route "PUT", what
+def put url=nil, what
+  add_route "PUT", url, what
 end
 
 # @param name [String]
@@ -50,3 +61,8 @@ def resource(name, &block)
   block.call
   @route_prefix.pop
 end
+
+# An alias is an url which have the same proprieties than the previous route
+def alias_route
+  raise "Not implemented yet"
+end

data/lib/nephos-server/router/load.rb

@@ -16,7 +16,7 @@ module Nephos
       end
       url = params.map{|e| e[:p]}.join("/+")
       url = "/" if url.empty?
-      what[:match] = /^#{url}\/*$/
+      what[:match] = what[:postfix] != false ? /^(?<url>#{url})(?<extension>\.\w+)?\/*$/ : /^(?<url>#{url})\/*$/
       # remove : in :param, and / in /param
       what[:params] = params.map{|e| e[:name] && e[:name][1..-1]}[1..-1] || []
     end
@@ -29,8 +29,16 @@ module Nephos
     # - :method
     def self.check_keys! what
       raise InvalidRouteUrl, "Missing URL" unless what.keys.include? :url
-      raise InvalidRouteController, "Missing Controller" unless what.keys.include? :controller
-      raise InvalidRouteMethod, "Missing Method" unless what.keys.include? :method
+      if what.keys.include? :to
+        match = what[:to].match(/(?<controller>\w+)\#(?<method>\w+)/)
+        raise InvalidRouteTo, "Invalid Controller#Method" unless match
+        what[:controller] = match["controller"]
+        what[:method] = match["method"]
+        what.delete :to
+      else
+        raise InvalidRouteController, "Missing Controller" unless what.keys.include? :controller
+        raise InvalidRouteMethod, "Missing Method" unless what.keys.include? :method
+      end
     end
 
     # @param what [Hash]

data/lib/nephos-server/router/main.rb

@@ -67,6 +67,8 @@ module Nephos
       env = req.env
       puts "#{req.env["REMOTE_ADDR"]} [#{req.request_method}] \t ---> \t #{req.path}" unless @silent
       call = find_route(req)
+      # require 'pry'
+      # binding.pry
       return error_404(req) if call.nil?
       begin
         return render_controller(req, call)

data/lib/nephos-server/server/responder.rb

@@ -69,7 +69,8 @@ module Nephos
     end
 
     def render_from_controller req, call
-      controller = Module.const_get(call[:controller]).new(req, call)
+      extension = req.path.match(call[:match])['extension']
+      controller = Module.const_get(call[:controller]).new(req, call, extension)
       method_to_call = call[:method]
 
       controller.execute_before_action(method_to_call)

data/nephos-server.gemspec

@@ -41,9 +41,10 @@ test/router.rb
 test/params.rb
 test/controller.rb
 test/functional.rb
-test/functional/server.rb
 test/functional/generator.rb
 test/functional/global.rb
+test/functional/router.rb
+test/functional/server.rb
 routes.rb
 
 app/dataset.rb

data/routes.rb

@@ -23,4 +23,5 @@ get url: "img/:image", controller: "MainController", method: "image"
 
 get url: "/get_cookies", controller: "MainController", method: "get_cookies"
 get url: "/add_cookie", controller: "MainController", method: "add_cookie"
-get url: "/err500", controller: "MainController", method: "err500"
+
+get "/err500", controller: "MainController", method: "err500"

data/test/functional/generator.rb

@@ -23,9 +23,13 @@ class TestNephosServerGenerator < Test::Unit::TestCase
     assert(Dir.exists? "/tmp/nephos-server-test/app")
     gemfile_data = File.read("/tmp/nephos-server-test/Gemfile").split("\n")
     assert(gemfile_data.include? "gem 'nephos'")
+
+    # if connected to internet only
+    assert(File.exists? "/tmp/nephos-server-test/Gemfile.lock")
     gemfile_lock_data = File.read("/tmp/nephos-server-test/Gemfile.lock").split
     assert(gemfile_lock_data.include? "nephos")
     assert(gemfile_lock_data.include? "nephos-server")
+
     `rm -rf /tmp/nephos-server-test 2> /tmp/null`
   end
 

data/test/functional/router.rb

@@ -0,0 +1,66 @@
+class TestNephosServerAppRouter < Test::Unit::TestCase
+
+  ENV_ALL_VALID_ROUTES = [
+    {"REQUEST_METHOD"=>"GET", "PATH_INFO"=>"/home/index"},
+    {"REQUEST_METHOD"=>"GET", "PATH_INFO"=>"/home/index/"},
+    {"REQUEST_METHOD"=>"GET", "PATH_INFO"=>"/home/index//"},
+    {"REQUEST_METHOD"=>"POST", "PATH_INFO"=>"/home/index/add"},
+    {"REQUEST_METHOD"=>"POST", "PATH_INFO"=>"/home/index/add/"},
+    {"REQUEST_METHOD"=>"POST", "PATH_INFO"=>"/home/index/add//"},
+    {"REQUEST_METHOD"=>"PUT", "PATH_INFO"=>"/home/index/rm"},
+    {"REQUEST_METHOD"=>"PUT", "PATH_INFO"=>"/home/index/rm/"},
+    {"REQUEST_METHOD"=>"PUT", "PATH_INFO"=>"/home/index/rm//"},
+    {"REQUEST_METHOD"=>"GET", "PATH_INFO"=>"/home"},
+    {"REQUEST_METHOD"=>"GET", "PATH_INFO"=>"/home/"},
+    {"REQUEST_METHOD"=>"GET", "PATH_INFO"=>"/home//"},
+
+    {"REQUEST_METHOD"=>"GET", "PATH_INFO"=>"/homes"},
+    {"REQUEST_METHOD"=>"GET", "PATH_INFO"=>"/homes/"},
+    {"REQUEST_METHOD"=>"GET", "PATH_INFO"=>"/homes//"},
+
+    {"REQUEST_METHOD"=>"GET", "PATH_INFO"=>"/"},
+    {"REQUEST_METHOD"=>"GET", "PATH_INFO"=>"/add"},
+    {"REQUEST_METHOD"=>"GET", "PATH_INFO"=>"/rm"},
+    # {"REQUEST_METHOD"=>"GET", "PATH_INFO"=>"/debug"},
+    {"REQUEST_METHOD"=>"GET", "PATH_INFO"=>"/hello"},
+
+    # {"REQUEST_METHOD"=>"GET", "PATH_INFO"=>"/image"},
+    {"REQUEST_METHOD"=>"GET", "PATH_INFO"=>"/image/image.jpg"},
+    {"REQUEST_METHOD"=>"GET", "PATH_INFO"=>"/img/image.jpg"},
+
+    {"REQUEST_METHOD"=>"GET", "PATH_INFO"=>"/get_cookies"},
+    {"REQUEST_METHOD"=>"GET", "PATH_INFO"=>"/add_cookie"},
+    # {"REQUEST_METHOD"=>"GET", "PATH_INFO"=>"/err500"},
+  ]
+
+  def test_router_all_valid_routes
+    router = Nephos::Router.new(silent: true)
+    r = []
+    ENV_ALL_VALID_ROUTES.each do |env|
+      r << router.execute(Rack::Request.new(env))
+    end
+
+    r.each_with_index do |rep, idx|
+      # puts ENV_ALL_VALID_ROUTES[idx]
+      # puts rep
+      begin
+        assert_equal(200, rep.status)
+      rescue => err
+        puts rep
+        puts err
+        raise
+      end
+    end
+  end
+
+  def test_router_on_invalid
+    router = Nephos::Router.new(silent: true)
+    not_valid = {"REQUEST_METHOD"=>"GET", "PATH_INFO"=>"/not_a_valid_route"}
+    almost_valid = {"REQUEST_METHOD"=>"GET", "PATH_INFO"=>"/get_cookie"}
+    bad_verb = {"REQUEST_METHOD"=>"POST", "PATH_INFO"=>"/get_cookies"}
+    assert_equal(404, router.execute(Rack::Request.new(not_valid)).status)
+    assert_equal(404, router.execute(Rack::Request.new(almost_valid)).status)
+    assert_equal(404, router.execute(Rack::Request.new(bad_verb)).status)
+  end
+
+end

data/test/router.rb

@@ -187,7 +187,6 @@ class TestNephosServerRouter < Test::Unit::TestCase
   REQ_POST_INDEX_XXX_ID = Rack::Request.new({"REQUEST_METHOD"=>"POST", "PATH_INFO"=>"/index/XXX/id"})
   REQ_POST_INDEX_XXX_XXX = Rack::Request.new({"REQUEST_METHOD"=>"POST", "PATH_INFO"=>"/index/XXX/XXX"})
 
-  # TODO : FIX
   def test_routing_matching_simple_with_arguments2
     reset_routes!
     get url: "/index", controller: "TestController", method: "method1", silent: true
@@ -208,4 +207,50 @@ class TestNephosServerRouter < Test::Unit::TestCase
     assert(!Nephos::Router.new.find_route(REQ_POST_INDEX_XXX_XXX))
   end
 
+  def test_routing_extension
+    reset_routes!
+    get url: "/index", controller: "TestController", method: "method1", silent: true
+    get url: "/indexno", controller: "TestController", method: "method1", silent: true, postfix: false
+    ok1 = Rack::Request.new({"REQUEST_METHOD"=>"GET", "PATH_INFO"=>"/index"})
+    ok2 = Rack::Request.new({"REQUEST_METHOD"=>"GET", "PATH_INFO"=>"/index.html"})
+    ok3 = Rack::Request.new({"REQUEST_METHOD"=>"GET", "PATH_INFO"=>"/index.json"})
+    ok4 = Rack::Request.new({"REQUEST_METHOD"=>"GET", "PATH_INFO"=>"/index.xhr"})
+    ok5 = Rack::Request.new({"REQUEST_METHOD"=>"GET", "PATH_INFO"=>"/indexno"})
+    ko1 = Rack::Request.new({"REQUEST_METHOD"=>"GET", "PATH_INFO"=>"/index/html"})
+    ko2 = Rack::Request.new({"REQUEST_METHOD"=>"GET", "PATH_INFO"=>"/indexno.html"})
+    ko3 = Rack::Request.new({"REQUEST_METHOD"=>"GET", "PATH_INFO"=>"/indexno.json"})
+    ko4 = Rack::Request.new({"REQUEST_METHOD"=>"GET", "PATH_INFO"=>"/indexno.xhr"})
+    assert(Nephos::Router.new.find_route(ok1))
+    assert(Nephos::Router.new.find_route(ok2))
+    assert(Nephos::Router.new.find_route(ok3))
+    assert(Nephos::Router.new.find_route(ok4))
+    assert(Nephos::Router.new.find_route(ok5))
+    assert(!Nephos::Router.new.find_route(ko1))
+    assert(!Nephos::Router.new.find_route(ko2))
+    assert(!Nephos::Router.new.find_route(ko3))
+    assert(!Nephos::Router.new.find_route(ko4))
+  end
+
+  def test_routing_eze_router
+    reset_routes!
+    get url: "/index", controller: "TestController", method: "method1", silent: true
+    get url: "/index", to: "TestController#method1", method: "method1", silent: true
+    assert_equal Nephos::Router::ROUTES[0], Nephos::Router::ROUTES[1]
+  end
+
+  def test_routing_multiple_url
+    reset_routes!
+    get url: ["/index"], controller: "TestController", method: "method1", silent: true
+    get url: "/index", controller: "TestController", method: "method1", silent: true
+    reset_routes!
+    get url: ["/index", "/index"], controller: "TestController", method: "method1"
+    get url: ["/index", "/index"], controller: "TestController", method: "method1"
+    assert_equal Nephos::Router::ROUTES[0], Nephos::Router::ROUTES[1]
+    assert_equal Nephos::Router::ROUTES[1], Nephos::Router::ROUTES[2]
+    assert_equal Nephos::Router::ROUTES[2], Nephos::Router::ROUTES[3]
+    reset_routes!
+    get url: ["/index", "/me", "/other"], controller: "TestController", method: "method1"
+    assert_equal 3, Nephos::Router::ROUTES.size
+  end
+
 end

data/version

@@ -1 +1 @@
-0.6.4
+0.6.5

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nephos-server
 version: !ruby/object:Gem::Version
-  version: 0.6.4
+  version: 0.6.5
 platform: ruby
 authors:
 - poulet_a
@@ -31,7 +31,7 @@ cert_chain:
   tcYkgfqUJPitIJx1RvWZpIyH5uJhRUYK3+vU9nMOxez5WbIlC1TtpByKAPMX+sht
   gib3AoIT8jh/2w==
   -----END CERTIFICATE-----
-date: 2015-10-03 00:00:00.000000000 Z
+date: 2015-10-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nomorebeer
@@ -135,6 +135,7 @@ files:
 - test/functional.rb
 - test/functional/generator.rb
 - test/functional/global.rb
+- test/functional/router.rb
 - test/functional/server.rb
 - test/params.rb
 - test/responder.rb
@@ -164,6 +165,8 @@ rubyforge_project:
 rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
-summary: "* Fix application generator (replace in the gemfile nephos-server by nephos)"
+summary: "* Improve routing helpers (optional url parameter) * Add new functional
+  tests (router) * Add extension for url (.html, ...) * Add improved router helper
+  (simple destination, alias)"
 test_files: []
 has_rdoc: