mynyml-simple_router 0.1 → 0.8

data/Rakefile

@@ -22,7 +22,7 @@ end
 
 spec = Gem::Specification.new do |s|
   s.name            = 'simple_router'
-  s.version         = '0.1'
+  s.version         = '0.8'
   s.summary         = "Minimalistic, simple router meant to be used with pure rack applications."
   s.description     = "Minimalistic, simple router meant to be used with pure rack applications."
   s.author          = "Martin Aumont"
@@ -30,7 +30,7 @@ spec = Gem::Specification.new do |s|
   s.homepage        = ''
   s.has_rdoc        = true
   s.require_path    = "lib"
-  s.files           = all_except(/doc\/.*/)
+  s.files           = all_except([/doc\/.*/, /pkg\/*/])
 end
 
 Rake::GemPackageTask.new(spec) do |p|

data/examples/rack_app.ru

@@ -0,0 +1,45 @@
+require 'pathname'
+root  =  Pathname(__FILE__).dirname.parent.expand_path
+$:.unshift(root.join('lib'))
+
+# run me with:
+#   $rackup examples/rack_app.ru
+# --------------------------------------------------
+require 'rubygems'
+require 'simple_router'
+
+class App
+  include SimpleRouter::DSL
+
+  get '/' do |params|
+    <<-html
+    <pre>
+      params: #{params.inspect}
+    </pre>
+    html
+  end
+
+  get '/:foo.:type' do |foo, type, params|
+    <<-html
+    <pre>
+      foo: #{foo.inspect}
+      type: #{type.inspect}
+      params: #{params.inspect}
+    </pre>
+    html
+  end
+
+  def call(env)
+    request = Rack::Request.new(env)
+
+    verb = request.request_method.downcase.to_sym
+    path = Rack::Utils.unescape(request.path_info)
+
+    route, args = self.class.routes.match(verb, path)
+    route.nil? ?
+      [404, {'Content-Type' => 'text/html'}, '404 page not found'] :
+      [200, {'Content-Type' => 'text/html'}, [route.action.call(*args.push(request.params))]]
+  end
+end
+
+run App.new

data/lib/simple_router/engines/simple_engine.rb

@@ -1,29 +1,101 @@
+require 'pathname'
+
 module SimpleRouter
   module Engines
-    class SimpleEngine
-
-      # Finds a route definition that matches a path
-      #
-      # ===== Arguments
-      # * path: actual path to match (e.g. ENV['PATH_INFO'])
-      # * routes: array of user defined routes
-      #
-      # ===== Returns
-      # Array of two elements:
-      #
-      # * index 0: first matching route
-      # * index 1: array of values for route variables, in the order they were specified
-      #
-      # ===== Examples
-      #
-      #   SimpleEngine.match('/foo', ['/', '/foo', '/bar/baz'])   #=> ['/foo', []]
-      #   SimpleEngine.match('/80/07/01', ['/:year/:month/:day']) #=> ['/foo', ['80', '07', '01']]
-      #
-      def self.match(path, routes)
-        routes.each do |route|
-          return route if route == path
+    module SimpleEngine #:nodoc:
+
+      def self.match(*args)
+        Base.match(*args)
+      end
+
+      class Base
+        # Finds a route definition that matches a path
+        #
+        # ===== Arguments
+        # * path: actual path to match (e.g. ENV['PATH_INFO'])
+        # * routes: array of 'routes', where each route is composed of [pattern, options]. If route isn't an array, an empty options hash is assumed
+        #
+        # Currently, this engine implementation ignores route options.
+        #
+        # ===== Returns
+        # Array of two elements:
+        #
+        # * index 0: first matching route
+        # * index 1: array of values for the matched route's variables (in the order they were specified in the route)
+        #
+        # ===== Examples
+        #
+        #   SimpleEngine.match('/foo', ['/', '/foo', '/bar/baz'])   #=> ['/foo', []]
+        #   SimpleEngine.match('/80/07/01', ['/:year/:month/:day']) #=> ['/foo', ['80', '07', '01']]
+        #
+        def self.match(path, routes)
+          path     = Path.new(path)
+          patterns = routes.map {|route| Pattern.new(Array(route).first) }
+
+          patterns.each do |pattern|
+            return [pattern.to_s, pattern.vars] if pattern == path
+          end
+
+          [nil, []]
+        end
+      end
+
+      class Path #:nodoc:
+        attr_accessor :parts, :ext
+
+        def initialize(path)
+          self.parts, self.ext = split_path(path)
+        end
+
+        def to_s
+          '/' + self.parts.join('/') + self.ext
         end
-        nil
+
+        private
+          def split_path(path)
+            path  = path.to_s
+            ext   = Pathname(path).extname
+            path  = path.sub(/#{ext}$/,'')
+            parts = path.split('/').reject {|part| part.empty? }
+            [parts, ext]
+          end
+      end
+
+      class Pattern < Path #:nodoc:
+
+        def variables
+          return [] unless @match
+
+          a = []
+          self.parts.each_with_index do |part,i|
+            a << @match.parts[i] if part[0] == ?:
+          end
+          a << @match.ext[1..-1] if self.ext[1] == ?:
+          a
+        end
+        alias :vars :variables
+
+        def ==(path)
+          is_match = size_match?(path) && ext_match?(path) && static_match?(path)
+          @match = path if is_match
+          is_match
+        end
+
+        private
+          def size_match?(path)
+            self.parts.size == path.parts.size
+          end
+
+          def ext_match?(path)
+            (self.ext == path.ext) || (self.ext[1] == ?: && !path.ext.empty?)
+          end
+
+          def static_match?(path)
+            self.parts.each_with_index do |part,i|
+              return false unless part[0] == ?: || path.parts[i] == part
+            end
+            true
+          end
       end
     end
   end

data/lib/simple_router/routes.rb

@@ -1,5 +1,5 @@
 module SimpleRouter
-  class Routes < Array #:nodoc:
+  class Routes < Array
 
     # routing engine
     attr_accessor :engine
@@ -13,16 +13,20 @@ module SimpleRouter
     end
 
     def match(verb, path)
-      unless self.empty?
-        routes = self.select {|route| route.verb == verb }
-        paths  = routes.map  {|route| route.path }
+      none = [nil, nil]
+      return none if self.empty?
 
-        path = self.engine.match(path, paths)
-        routes.detect {|route| route.path == path }
-      end
+      routes = self.select {|route| route.verb == verb }
+      paths  = routes.map  {|route| route.path }
+
+      path, vars = self.engine.match(path, paths)
+      return none if path.nil?
+
+      route = routes.detect {|route| route.path == path }
+      [route, vars]
     end
 
-    class Route < Array #:nodoc:
+    class Route
       attr_accessor :verb,:path,:options,:action
 
       def initialize(verb, path, options, &action)

data/simple_router.gemspec

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: simple_router
 version: !ruby/object:Gem::Version 
-  version: "0.1"
+  version: "0.8"
 platform: ruby
 authors: 
 - Martin Aumont
@@ -30,6 +30,8 @@ files:
 - test/test_dsl.rb
 - test/test_routes.rb
 - test/test_helper.rb
+- examples
+- examples/rack_app.ru
 - simple_router.gemspec
 - TODO
 - lib

data/test/engines/test_simple_engine.rb

@@ -1,12 +1,126 @@
 require 'test/test_helper'
 
-Engine = SimpleRouter::Engines::SimpleEngine
-
 class SimpleEngineTest < Test::Unit::TestCase
+  include SimpleRouter::Engines::SimpleEngine
+
+  test "matches static paths" do
+    Base.match('/',    ['/', '/foo']).first.should be('/')
+    Base.match('/foo', ['/', '/foo']).first.should be('/foo')
+    Base.match('/bar', ['/', '/foo']).first.should be(nil)
+  end
+
+  test "matches variable paths" do
+    path, vars = Base.match('/80/07', ['/foo', '/:year/:month'])
+    path.should be('/:year/:month')
+    vars.should be(['80','07'])
+  end
+
+  test "matches hybrid paths" do
+    path, vars = Base.match('/archives/80/07', ['/foo', '/archives/:year/:month'])
+    path.should be('/archives/:year/:month')
+    vars.should be(['80','07'])
+  end
+
+  test "ignores leading slash in path" do
+    path, vars = Base.match('archives/80/07', ['/foo', '/archives/:year/:month'])
+    path.should be('/archives/:year/:month')
+    vars.should be(['80','07'])
+  end
+
+  test "no matches" do
+    path, vars = Base.match('/80/07/01', ['/foo', '/:year/:month'])
+    path.should be(nil)
+    vars.should be([])
+  end
+
+  test "treats extention as pattern part" do
+    path, vars = Base.match('/a/b.xml', ['/:foo/:bar', '/:foo/:bar.:type'])
+    path.should be('/:foo/:bar.:type')
+    vars.should be(['a','b','xml'])
+  end
+end
+
+class PatternTest < Test::Unit::TestCase
+  include SimpleRouter::Engines::SimpleEngine
+
+  test "static pattern matches a path" do
+    path    = Path.new('/foo/bar')
+    pattern = Pattern.new('/foo/bar')
+
+    assert pattern == path
+  end
+
+  test "variable pattern matches a path" do
+    path    = Path.new('/foo/bar')
+    pattern = Pattern.new('/:foo/:bar')
+
+    assert pattern == path
+  end
+
+  test "pattern variables" do
+    path    = Path.new('/foo/bar/baz')
+    pattern = Pattern.new('/:a/:b/:c')
+
+    assert pattern == path
+    pattern.vars.should be(%w( foo bar baz ))
+  end
+
+  test "pattern variables with extention" do
+    path    = Path.new('/foo/bar/baz.xml')
+    pattern = Pattern.new('/:a/:b/:c.:type')
+
+    assert pattern == path
+    pattern.vars.should be(%w( foo bar baz xml ))
+  end
+
+  test "variable pattern matches a path with static extention" do
+    path    = Path.new('/foo/bar.xml')
+    pattern = Pattern.new('/:foo/:bar.xml')
+
+    assert pattern == path
+  end
+
+  test "variable pattern matches a path with variable extention" do
+    path    = Path.new('/foo/bar.xml')
+    pattern = Pattern.new('/:foo/:bar.:type')
+
+    assert pattern == path
+  end
+
+  test "pattern without extention doesn't match path with extention" do
+    path    = Path.new('/foo/bar.xml')
+    pattern = Pattern.new('/:foo/:bar')
+
+    assert pattern != path
+  end
+
+  test "pattern with static extention doesn't match path without extention" do
+    path    = Path.new('/foo/bar')
+    pattern = Pattern.new('/:foo/:bar.xml')
+
+    assert pattern != path
+  end
+
+  test "pattern with variable extention doesn't match path without extention" do
+    path    = Path.new('/foo/bar')
+    pattern = Pattern.new('/:foo/:bar.:type')
+
+    assert pattern != path
+  end
+
+  test "doesn't ignore dots in path parts" do
+    path    = Path.new('/foo/bar.baz/abc')
+    pattern = Pattern.new('/:a/:b/:c')
+
+    assert pattern == path
+    pattern.variables.should be(%w( foo bar.baz abc ))
+  end
+
+  test "doesn't get confused with extention when path contains other dots" do
+    path    = Path.new('/foo/bar.baz/abc.xml')
+    pattern = Pattern.new('/:a/:b/:c.:type')
 
-  test "matches simple paths" do
-    Engine.match('/',    ['/', '/foo']).should be('/')
-    Engine.match('/foo', ['/', '/foo']).should be('/foo')
-    Engine.match('/bar', ['/', '/foo']).should be(nil)
+    assert pattern == path
+    pattern.variables.should be(%w( foo bar.baz abc xml ))
   end
 end

data/test/test_dsl.rb

@@ -33,6 +33,6 @@ class DslTest < Test::Unit::TestCase
     App.get('/bar') { 'bar' }
 
     App.routes.match(:get, '/foo').should_not  be( nil )
-    App.routes.match(:get, '/foo').action.call.should be('foo')
+    App.routes.match(:get, '/foo').first.action.call.should be('foo')
   end
 end

data/test/test_routes.rb

@@ -21,14 +21,14 @@ class RoutesTest < Test::Unit::TestCase
     @routes.add(:get, '/bar', {}, &@action)
 
     @routes.match(:get, '/bar').should_not  be(nil)
-    @routes.match(:get, '/bar').path.should be('/bar')
+    @routes.match(:get, '/bar').first.path.should be('/bar')
   end
 
   test "returns nil when no route matches" do
     @routes.add(:get, '/foo', {}, &@action)
     @routes.add(:get, '/bar', {}, &@action)
 
-    @routes.match('/baz', :get).should be(nil)
+    @routes.match('/baz', :get).should be([nil,nil])
   end
 
   ## engine

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: mynyml-simple_router
 version: !ruby/object:Gem::Version 
-  version: "0.1"
+  version: "0.8"
 platform: ruby
 authors: 
 - Martin Aumont
@@ -30,6 +30,8 @@ files:
 - test/test_dsl.rb
 - test/test_routes.rb
 - test/test_helper.rb
+- examples
+- examples/rack_app.ru
 - simple_router.gemspec
 - TODO
 - lib