rocketio 0.1.0 → 0.2.0

data/lib/rocketio/controller/authorization.rb

@@ -13,8 +13,8 @@ module RocketIO
     #
     def self.token_auth *args, &block
       opts = args.last.is_a?(Hash) ? args.pop : {}
-      (args.any? ? args.map!(&:to_sym) : RocketIO::REQUEST_METHODS.values).each do |rm|
-        (@__token_auth__ ||= {})[rm] = {
+      (args.any? ? args.map(&:to_sym) : [:*]).each do |method|
+        (@__token_auth__ ||= {})[method] = {
           realm: opts[:realm] || RocketIO::DEFAULT_TOKEN_AUTH_REALM.freeze,
           block: block
         }
@@ -25,13 +25,13 @@ module RocketIO
     def self.define_token_auth_methods source = self
       prompts = allocate.token_auth.merge(source.instance_variable_get(:@__token_auth__) || {}).freeze
       return if prompts.empty?
-      private_api << define_method(:token_auth) {prompts}
+      api.delete define_method(:token_auth) {prompts}
     end
 
     def token_auth; RocketIO::EMPTY_HASH end
 
     def validate_or_request_authorization_if_needed
-      return unless auth = token_auth[requested_method]
+      return unless auth = authorization_required?
       return if validate_token_auth(&auth[:block])
       throw(:__response__, request_token_auth(auth[:realm]))
     end
@@ -47,5 +47,9 @@ module RocketIO
     def request_token_auth realm = RocketIO::DEFAULT_TOKEN_AUTH_REALM
       RocketIO::TokenAuth.authentication_request(realm)
     end
+
+    def authorization_required?
+      token_auth[requested_method] || token_auth[:*]
+    end
   end
 end

data/lib/rocketio/controller/error_handlers.rb

@@ -38,12 +38,12 @@ module RocketIO
     def self.define_error_handlers_methods source = self
       handlers = (source.instance_variable_get(:@__error_handlers__) || {}).each_with_object({}) do |(code,block),o|
         o[code] = :"__#{code}_error_handler__"
-        private_api << define_method(o[code], &block)
+        api.delete define_method(o[code], &block)
       end
       handlers.update(allocate.error_handlers)
       return if handlers.empty?
       handlers.freeze
-      private_api << define_method(:error_handlers) {handlers}
+      api.delete define_method(:error_handlers) {handlers}
     end
 
     def error_handlers; RocketIO::EMPTY_HASH end
@@ -76,17 +76,21 @@ module RocketIO
     # 409: Wrong number of arguments received
     error 409 do
       RocketIO.error_renderer(409, xhr?, {
-        env: env,
-        controller: self.class,
-        resolved_path: url,
-        expected_parameters: parameters_policy[env[RocketIO::REQUEST_METHOD]],
-        received_parameters: path_params
+        url: url,
+        controller: self.class.to_s,
+        requested_method: requested_method,
+        expected: api[requested_method][:parameters_policy],
+        received: path_params_array
       })
     end
 
     # 501: Not Implemented
     error 501 do
-      RocketIO.error_renderer(501, xhr?, env: env)
+      RocketIO.error_renderer(501, xhr?, {
+        url: url,
+        controller: self.class.to_s,
+        requested_method: requested_method
+      })
     end
   end
 end

data/lib/rocketio/controller/filters.rb

@@ -11,47 +11,42 @@ module RocketIO
     #       and can override them selectively, by name
     #
     # @note wildcard filters will run before/around/after any methods,
-    #       that's it, if defining `before {}` and `before(:get) {}` filters
-    #       `get` method will run `before` filter then `before(:get)`
+    #       that's it, if defining `before {}` and `before(:index) {}` filters
+    #       `index` method will run `before` filter then `before(:index)`
     #
-    # @example run before any requested method, being it REST or websocket
+    # @example run before any method
     #   before do
     #     # some logic here
     #   end
     #
-    # @example run only before GET
-    #   before :get do
+    # @example run only before :create
+    #   before :create do
     #     # some logic here
     #   end
     #
-    # @example run only around PUT and POST
-    #   around :put, :post do |app|
+    # @example run only around :create and :edit
+    #   around :create, :edit do |app|
     #     # some logic here
     #     app.call
     #   end
     #
-    # @example run only after :register websocket call
-    #   after :register do
-    #     # some logic here
-    #   end
-    #
     # @example define a filter that does nothing. useful to override inherited filters.
-    #   before :get
+    #   before {}
     #
-    # @example run 2 blocks before GET
+    # @example run 2 blocks before :create
     #   before do  # wildcard filter, will run before any method
     #     @user = User.find...
     #   end
     #
-    #   before :get do  # named filter, will run only before `get`
+    #   before :create do  # named filter, will run only before `create`
     #     # wildcard filter already executed so we have `@user` variable here
     #     @photo = @user.photos.find...
     #   end
     #
-    #   # before calling `get` two filters will be executed:
+    #   # at the moment we call :create two filters was executed:
     #   # - wildcard one
     #   # - named one
-    #   def get
+    #   def create
     #     # both @user and @photo variables available here
     #   end
     #
@@ -75,12 +70,12 @@ module RocketIO
       define_singleton_method define_methods do |source = self|
         filters = (source.instance_variable_get(var) || {}).each_with_object({}) do |(meth,block),o|
           o[meth] = :"__#{filter}_#{meth}__"
-          private_api << define_method(o[meth], &block)
+          api.delete define_method(o[meth], &block)
         end
         filters.update(allocate.__send__(filter))
         return unless filters.any?
         filters.freeze
-        private_api << define_method(filter) {filters}
+        api.delete define_method(filter) {filters}
       end
     end
 

data/lib/rocketio/controller/helpers.rb

@@ -83,7 +83,7 @@ module RocketIO
     #   pass User, :bob, :bobsen
     #
     def pass controller, *args
-      halt controller.initialize_controller(RocketIO::REQUEST_METHODS[request_method], args).call(env)
+      halt controller.new(requested_method, args).call(env)
     end
 
     # stop executing any code and send response to browser.

data/lib/rocketio/controller/middleware.rb

@@ -24,7 +24,7 @@ module RocketIO
     def self.define_middleware_methods source = self
       middleware = ((source.instance_variable_get(:@__middleware__) || []) + allocate.middleware).uniq.freeze
       return if middleware.empty?
-      private_api << define_method(:middleware) {middleware}
+      api.delete define_method(:middleware) {middleware}
     end
 
     def middleware; RocketIO::EMPTY_ARRAY end

data/lib/rocketio/controller/render/engine.rb

@@ -60,14 +60,14 @@ module RocketIO
       return unless engine = source.instance_variable_get(:@__engine__)
       if Proc === engine
         selfengine = allocate.engine
-        private_api << define_method(:__rocketio_engine__, &engine)
-        private_api << define_method(:engine) {
+        api.delete define_method(:__rocketio_engine__, &engine)
+        api.delete define_method(:engine) {
           engine, *engine_options = __rocketio_engine__
           return selfengine unless engine
           [RocketIO.engine_class(engine), engine_options.freeze].freeze
         }
       else
-        private_api << define_method(:engine) {engine}
+        api.delete define_method(:engine) {engine}
       end
     end
 

data/lib/rocketio/controller/render/layout.rb

@@ -17,7 +17,7 @@ module RocketIO
     def self.define_layout_methods source = self
       return unless source.instance_variables.include?(:@__layout__)
       layout = source.instance_variable_get(:@__layout__)
-      private_api << define_method(:layout) {layout}
+      api.delete define_method(:layout) {layout}
     end
 
     # by default no layout used, so this method returns nil.

data/lib/rocketio/controller/render/layouts.rb

@@ -59,25 +59,25 @@ module RocketIO
         o[name] = :"__#{name}_layout__"
         if setup[:block]
           # block given, do not search for file, use returned value instead
-          private_api << define_method(o[name], &setup[:block])
+          api.delete define_method(o[name], &setup[:block])
         elsif setup[:file]
           # file given, search the file in original controller dirname
-          private_api << meth_name = :"__#{name}_layout_file__"
+          meth_name = :"__#{name}_layout_file__"
           meth_proc = setup[:file].is_a?(::Proc) ? setup[:file] : -> {setup[:file]}
-          private_api << define_method(meth_name, &meth_proc)
-          private_api << define_method(o[name]) {
+          api.delete define_method(meth_name, &meth_proc)
+          api.delete define_method(o[name]) {
             engine, * = resolve_engine
             read_template(find_template(setup[:root], __send__(meth_name), engine))
           }
         else
           # only name given, search for a file with same name in controller's dirname
-          private_api << define_method(o[name]) {
+          api.delete define_method(o[name]) {
             engine, * = resolve_engine
             read_template(find_template(self.dirname, setup[:name], engine))
           }
         end
       end.freeze
-      private_api << define_method(:layouts) {layouts}
+      api.delete define_method(:layouts) {layouts}
     end
 
     def layouts; RocketIO::EMPTY_HASH end

data/lib/rocketio/controller/render/template_vars.rb

@@ -17,12 +17,12 @@ module RocketIO
       vars = source.instance_variable_get(:@__template_vars__).each_with_object(allocate.__template_vars__.dup) do |(name,value),o|
         o[name] = :"__#{name}_template_var__"
         if value.is_a?(Proc)
-          private_api << define_method(o[name], &value)
+          api.delete define_method(o[name], &value)
         else
-          private_api << define_method(o[name]) {value}
+          api.delete define_method(o[name]) {value}
         end
       end.freeze
-      private_api << define_method(:__template_vars__) {vars}
+      api.delete define_method(:__template_vars__) {vars}
     end
 
     def __template_vars__; RocketIO::EMPTY_HASH end

data/lib/rocketio/controller/render/templates.rb

@@ -57,25 +57,25 @@ module RocketIO
         o[name] = :"__#{name}_template__"
         if setup[:block]
           # block given, do not search for file, use returned value instead
-          private_api << define_method(o[name], &setup[:block])
+          api.delete define_method(o[name], &setup[:block])
         elsif setup[:file]
           # file given, search the file in original controller dirname
-          private_api << meth_name = :"__#{name}_template_file__"
+          meth_name = :"__#{name}_template_file__"
           meth_proc = setup[:file].is_a?(Proc) ? setup[:file] : -> {setup[:file]}
-          private_api << define_method(meth_name, &meth_proc)
-          private_api << define_method(o[name]) {
+          api.delete define_method(meth_name, &meth_proc)
+          api.delete define_method(o[name]) {
             engine, * = resolve_engine
             read_template(find_template(setup[:root], __send__(meth_name), engine))
           }
         else
           # only name given, search for a file with same name in controller's dirname
-          private_api << define_method(o[name]) {
+          api.delete define_method(o[name]) {
             engine, * = resolve_engine
             read_template(find_template(self.dirname, setup[:name], engine))
           }
         end
       end.freeze
-      private_api << define_method(:templates) {templates}
+      api.delete define_method(:templates) {templates}
     end
 
     def templates; RocketIO::EMPTY_HASH end

data/lib/rocketio/controller/sessions.rb

@@ -56,7 +56,7 @@ module RocketIO
     def self.define_sessions_methods source = self
       return unless source.instance_variables.include?(:@__sessions__)
       sessions = source.instance_variable_get(:@__sessions__)
-      private_api << define_method(:sessions) {sessions}
+      api.delete define_method(:sessions) {sessions}
     end
 
     def sessions; end

data/lib/rocketio/error_templates/409.html

@@ -1,7 +1,11 @@
-<h1>Wrong number of arguments received</h1>
-<h2>
-  Controller: {{controller}}<br>
-  Resolved Path: {{resolved_path}}<br>
-  Expected Parameters: {{expected_parameters}}<br>
-  Received Parameters: {{received_parameters}}<br>
-</h2>
+<h1>409: Wrong arguments</h1>
+<h3>
+  <b>{{url}}</b> URL resolved to <b>{{controller}}#{{requested_method}}</b> method
+  but it was called with wrong arguments.
+  <div>
+    Expected: {min: {{expected.min}}, max: {{expected.max}}}
+  </div>
+  <div>
+    Received: {{received}}
+  </div>
+</h3>

data/lib/rocketio/error_templates/501.html

@@ -1,6 +1,6 @@
 <h1>501: Not Implemented</h1>
 <hr>
-<h2>
-  "{{env.PATH_INFO}}" page found
-  but it is not supposed to work through "{{env.REQUEST_METHOD}}" request method
-</h2>
+<h3>
+  <b>{{url}}</b> URL resolved to <b>{{controller}}</b> controller
+  but it does not respond to <b>{{requested_method}}</b> method
+</h3>

data/lib/rocketio/router.rb

@@ -1,26 +1,42 @@
 module RocketIO
   class Router
-    ROOT_PATH_PIECES  = [''.freeze].freeze
+
+    ROOT_PATH_PIECES = [EMPTY_STRING].freeze
+    PATH_SPLITTER = /\/+/.freeze
+
     attr_reader :controllers, :routes
 
     def initialize *controllers
       @controllers = controllers.flatten.compact.uniq
-      @routes = build_routes
+      @controller_routes = controller_routes()
       freeze!
     end
 
+    # fully traversing the tree and use the last matched controller
     def resolve_path path
-      controllers = @routes
+      controller_routes = @controller_routes
       pieces = path_pieces(path)
-      depth  = -1
-      controller  = nil
-      offset = 0
-      while controllers = controllers[pieces[depth += 1]]
-        next unless controllers[0]
-        controller  = controllers[0]
-        offset = depth + 1
+      depth = -1
+      controller = nil
+      path_params = []
+
+      while controller_routes = controller_routes[pieces[depth += 1]]
+        # do not use `next unless controller = controller_routes[0]` here
+        # cause this may override earlier found controller.
+        next unless controller_routes[0]
+        controller = controller_routes[0]
+        path_params = pieces[ (depth + 1) .. -1 ]
       end
-      [controller, pieces[offset .. -1]]
+
+      return EMPTY_ARRAY unless controller
+
+      method = if path_params.any? && controller.api[path_params[0].to_sym]
+        path_params.slice!(0).to_sym
+      else
+        INDEX_METHOD
+      end
+
+      [controller, method, path_params]
     end
 
     private
@@ -34,30 +50,28 @@ module RocketIO
     #
     def path_pieces path
       return ROOT_PATH_PIECES if path == SLASH # that's root path, /
-      path.to_s.split(/\/+/)
+      path.to_s.split(PATH_SPLITTER)
     end
 
     # building a routing tree
     #
     # @return [Hash]
     #
-    def build_routes
-      map = {}
-      @controllers.each do |controller|
+    def controller_routes
+      controllers.each_with_object({}) do |controller,map|
         [controller.url, *controller.aliases].each do |url|
           depth = 0
           pieces = path_pieces(url)
-          pieces.inject(map) do |map,chunk|
-            map[chunk] ||= {}
-            map[chunk][0] = controller if pieces.size == (depth += 1)
-            map[chunk]
+          pieces.reduce(map) do |pieces_map,chunk|
+            pieces_map[chunk] ||= {}
+            pieces_map[chunk][0] = controller if pieces.size == (depth += 1)
+            pieces_map[chunk]
           end
         end
       end
-      map
     end
 
-    # freezing the application cause modifying it at runtime may blow the universe
+    # freezing the router cause modifying it at runtime may blow the universe
     def freeze!
       self.freeze
     end

data/lib/rocketio/version.rb

@@ -1,3 +1,3 @@
 module RocketIO
-  VERSION = '0.1.0'.freeze
+  VERSION = '0.2.0'.freeze
 end

data/rocketio.gemspec

@@ -24,4 +24,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'rake', '~> 10.0'
   spec.add_development_dependency 'tokyo', '~> 0'
   spec.add_development_dependency 'rack-radar', '~> 0'
+  spec.add_development_dependency 'pry', '~> 0'
+  spec.add_development_dependency 'pry-byebug', '~> 3'
 end

data/test/aliases_test.rb

@@ -4,13 +4,13 @@ class A < RocketIO::Controller
   alias_url :x
   alias_url :y
 
-  def get; url end
+  def index; url end
 
   class B < self
     alias_url :x
     alias_url :y
 
-    def get; url end
+    def index; url end
   end
 end