rutter 0.1.2 → 0.2.0

data/lib/rutter/verbs.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Rutter
+  # Supported request verbs.
+  #
+  # @return [Array]
+  VERBS = %w[GET POST PUT PATCH DELETE OPTIONS].freeze
+end

data/lib/rutter/version.rb

@@ -2,5 +2,5 @@
 
 module Rutter
   # Current version number.
-  VERSION = "0.1.2"
+  VERSION = "0.2.0"
 end

data/rutter.gemspec

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
-require File.expand_path("../lib/rutter/version", __FILE__)
+require File.expand_path("lib/rutter/version", __dir__)
 
 Gem::Specification.new do |spec|
   spec.name = "rutter"
   spec.version = Rutter::VERSION
   spec.summary = "HTTP router for Rack."
 
-  spec.required_ruby_version = ">= 2.4.0"
+  spec.required_ruby_version = ">= 2.5.0"
   spec.required_rubygems_version = ">= 2.5.0"
 
   spec.license = "MIT"
@@ -20,7 +20,8 @@ Gem::Specification.new do |spec|
   spec.test_files = spec.files.grep(%r{^(spec)/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "rack", "~> 2.0"
+  spec.add_runtime_dependency "mustermann", "~> 1.0"
+  spec.add_runtime_dependency "rack", "~> 2.0"
 
   spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake"

data/spec/integration/rack_spec.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require "spec_helper"
-
-RSpec.describe "Rack integration" do
-  let(:router) do
+RSpec.describe "Rack compatible", type: :request do
+  let :router do
     Rutter.new do
-      get "/books", to: ->(_env) { [200, {}, ["Books"]] }
+      get "/say/:message", to: (lambda do |env|
+        [200, {}, ["I say, #{env['rutter.params']['message']}"]]
+      end)
     end
   end
 
@@ -13,21 +13,29 @@ RSpec.describe "Rack integration" do
     router.freeze
   end
 
-  describe "with match" do
+  context "with match" do
     it "calls the matched endpoint" do
-      get "/books"
-      expect(last_response.status).to eq(200)
-      expect(last_response.body).to eq("Books")
+      get "/say/hello-world"
+
+      expect(last_response.status)
+        .to eq(200)
+      expect(last_response.body)
+        .to eq("I say, hello-world")
+      expect(last_response.headers["Content-Length"])
+        .to eq("18")
     end
   end
 
-  describe "with no match" do
+  context "with no match" do
     it "returns 404" do
       get "/authors"
 
-      expect(last_response.status).to eq(404)
-      expect(last_response.body).to eq("Route Not Found")
-      expect(last_response.headers["X-Cascade"]).to eq("pass")
+      expect(last_response.status)
+        .to eq(404)
+      expect(last_response.body)
+        .to eq("Not Found")
+      expect(last_response.headers["X-Cascade"])
+        .to eq("pass")
     end
   end
 end

data/spec/spec_helper.rb

@@ -2,9 +2,12 @@
 
 require "bundler/setup"
 
+unless ENV["CI"]
+  require "byebug"
+end
+
 if ENV["COVERAGE"] == "true"
   require "simplecov"
-  require "codeclimate-test-reporter"
 
   SimpleCov.start do
     command_name "spec"
@@ -15,27 +18,12 @@ end
 # Require support (helper) modules
 Dir["./spec/support/**/*.rb"].each { |f| require f }
 
-# Require library
-require "rack/test"
 require "rutter"
 
-# This file was generated by the `rspec --init` command. Conventionally, all
-# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
-# The generated `.rspec` file contains `--require spec_helper` which will cause
-# this file to always be loaded, without a need to explicitly require it in any
-# files.
-#
-# Given that it is always loaded, you are encouraged to keep this file as
-# light-weight as possible. Requiring heavyweight dependencies from this file
-# will add to the boot time of your test suite on EVERY test run, even for an
-# individual file that may not need all of that loaded. Instead, consider making
-# a separate helper file that requires the additional dependencies and performs
-# the additional setup, and require it from the spec files that actually need
-# it.
-#
 # See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
 RSpec.configure do |config|
-  config.include Rack::Test::Methods
+  # Disable monkey-pachting core ruby.
+  config.disable_monkey_patching!
 
   # rspec-expectations config goes here. You can use an alternate
   # assertion/expectation library such as wrong or the stdlib/minitest
@@ -66,34 +54,4 @@ RSpec.configure do |config|
   # inherited by the metadata hash of host groups and examples, rather than
   # triggering implicit auto-inclusion in groups with matching metadata.
   config.shared_context_metadata_behavior = :apply_to_host_groups
-
-  # This allows you to limit a spec run to individual examples or groups
-  # you care about by tagging them with `:focus` metadata. When nothing
-  # is tagged with `:focus`, all examples get run. RSpec also provides
-  # aliases for `it`, `describe`, and `context` that include `:focus`
-  # metadata: `fit`, `fdescribe` and `fcontext`, respectively.
-  config.filter_run_when_matching :focus
-
-  # Limits the available syntax to the non-monkey patched syntax that is
-  # recommended. For more details, see:
-  #   - http://rspec.info/blog/2012/06/rspecs-new-expectation-syntax/
-  #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
-  #   - http://rspec.info/blog/2014/05/notable-changes-in-rspec-3/#zero-monkey-patching-mode
-  config.disable_monkey_patching!
-
-  # This setting enables warnings. It's recommended, but in some cases may
-  # be too noisy due to issues in dependencies.
-  config.warnings = true
-
-  # Run specs in random order to surface order dependencies. If you find an
-  # order dependency and want to debug it, you can fix the order by providing
-  # the seed, which is printed after each run.
-  #     --seed 1234
-  config.order = :random
-
-  # Seed global randomization in this process using the `--seed` CLI option.
-  # Setting this allows you to use `--seed` to deterministically reproduce
-  # test failures related to randomization by passing the same `--seed` value
-  # as the one that triggered the failure.
-  Kernel.srand config.seed
 end

data/spec/support/rack.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "rack/test"
+
+module RSpec
+  module Support
+    module Rack
+      module_function
+
+      def env_for(uri = "", opts = {})
+        ::Rack::MockRequest.env_for(uri, opts)
+      end
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include RSpec::Support::Rack
+  config.include Rack::Test::Methods, type: :request
+end

data/spec/unit/builder_spec.rb

@@ -3,108 +3,120 @@
 module Rutter
   RSpec.describe Builder do
     let(:router) { Builder.new }
-
-    describe "#add" do
-      it "returns the created route object" do
-        route = router.get "/books", to: ->(env) {}
-        named_route = router.get "/named_books", to: ->(env) {}, as: :books
-
-        expect(route).to be_a(Route)
-        expect(named_route).to be_a(Route)
+    let(:endpoint) { ->(_) {} }
+
+    describe "#mount" do
+      it "matches path prefixes" do
+        route = router.mount endpoint, at: "/admin"
+
+        expect(route.match?(env_for("/")))
+          .to be_nil
+        expect(route.match?(env_for("/books")))
+          .to be_nil
+        expect(route.match?(env_for("/admin")))
+          .to eq("/admin")
+        expect(route.match?(env_for("/admin/books")))
+          .to eq("/admin")
       end
+    end
 
-      it "adds a route to the collection" do
-        router.get "/books", to: ->(env) {}
-        router.post "/books", to: ->(env) {}
-
-        expect(router.flat_map.size).to eq(2)
+    describe "#path" do
+      it "generates a path for named routes" do
+        router.get "/login", to: "sessions#new", as: :login
+        router.get "/books/:id", to: "books#show", as: :book
+
+        expect(router.path(:login))
+          .to eq("/login")
+        expect(router.path(:login, return_to: "/"))
+          .to eq("/login?return_to=%2F")
+        expect(router.path(:book, id: 82))
+          .to eq("/books/82")
       end
 
-      it "stores the name of the route" do
-        route = router.add "GET", "/books", as: :books, to: ->(env) {}
-        expect(router.named_map[:books]).to eq(route)
+      it "raises an error if route not founf" do
+        expect { router.path(:book) }
+          .to raise_error(RuntimeError, "No route called 'book' was found")
       end
+    end
 
-      it "normalizes route names" do
-        router.get "/books", as: :_bookie__books__, to: ->(env) {}
-        expect(router.named_map.key?(:bookie_books)).to eq(true)
+    describe "#url" do
+      it "generates a full URL for named routes" do
+        router = Rutter.new(base: "http://rutter.org")
+        router.get "/login", to: "sessions#new", as: :login
+        router.get "/books/:id", to: "books#show", as: :book
+
+        expect(router.url(:login))
+          .to eq("http://rutter.org/login")
+        expect(router.url(:login, return_to: "/"))
+          .to eq("http://rutter.org/login?return_to=%2F")
+        expect(router.url(:book, id: 82))
+          .to eq("http://rutter.org/books/82")
       end
 
-      it "raises an error if named route already been defined" do
-        router.get "/books", as: :books, to: ->(env) {}
+      it "supports adding a subdomain" do
+        router = Rutter.new(base: "http://rutter.org")
+        router.get "/login", to: "sessions#new", as: :login
 
-        expect { router.get "/books", as: :books, to: ->(env) {} }
-          .to raise_error("a route called 'books' has already been defined")
+        expect(router.url(:login, subdomain: "auth"))
+          .to eq("http://auth.rutter.org/login")
       end
-    end
 
-    describe "#root" do
-      it "adds a root path with a root name" do
-        route = router.root to: ->(env) {}
-
-        expect(route.path).to eq("/")
-        expect(router.named_map[:root]).to eq(route)
+      it "raises an error if route not founf" do
+        expect { router.url(:book) }
+          .to raise_error(RuntimeError, "No route called 'book' was found")
       end
     end
 
-    describe "verbs" do
-      Route::VERBS.each do |verb|
-        it "accept the #{verb} verb as method" do
-          router.send verb.downcase, "/", to: ->() {}
-          expect(router.flat_map[0].method).to eq(verb)
-        end
-      end
-    end
-
-    describe "#path" do
-      it "generates a URL path from the arguments" do
-        router.get "/users/:id(/:username)", to: "Users#show", as: :user
-
-        expect(router.path(:user, id: 45, username: "sandelius"))
-          .to eq("/users/45/sandelius")
-        expect(router.path(:user, id: 45)).to eq("/users/45")
+    describe "#add" do
+      it "raises an error if the verb is unsupported" do
+        expect { router.add("unknown", "/", to: endpoint) }
+          .to raise_error(ArgumentError, "Unsupported verb 'UNKNOWN'")
       end
 
-      it "raises an error if route has not been defined" do
-        expect { router.path(:user) }
-          .to raise_error("no route called 'user'")
-      end
-    end
+      it "normalize route names" do
+        route = router.get "/", to: endpoint, as: "_wierd/__name__"
 
-    describe "#url" do
-      it "generates a full URL" do
-        router.get "/users/:id", to: "Users#show", as: :user
-
-        expect(router.url(:user, id: 54)).to eq("http://example.com/users/54")
+        expect(router.named_map[:wierd_name])
+          .to eq(route)
       end
 
-      it "allows host scheme and subdomain to be set" do
-        router.get "/users/:id", to: "Users#show", as: :user
-
-        url = router.url(
-          :user,
-          id: 54, _host: "example.com", _scheme: "https", _subdomain: "api"
-        )
+      it "support using route constraints" do
+        route = router.get "/books/:id",
+                           to: endpoint,
+                           constraints: { id: /\d+/ }
 
-        expect(url).to eq("https://api.example.com/users/54")
+        expect(route.match?(env_for("/books/82")))
+          .to be(true)
+        expect(route.match?(env_for("/books/pickaxe")))
+          .to be(false)
       end
+    end
 
-      it "adds port if no 80 or 433" do
-        router.get "/users/:id", to: "Users#show", as: :user
-
-        expect(router.url(:user, id: 54, _port: 333))
-          .to eq("http://example.com:333/users/54")
+    describe "verbs" do
+      VERBS.each do |verb|
+        describe "##{verb.downcase}" do
+          it "recognize #{verb} verb" do
+            route = router.public_send verb.downcase, "/", to: endpoint
+
+            expect(router.verb_map[verb])
+              .to eq([route])
+          end
+        end
       end
     end
 
     describe "#freeze" do
-      it "freezes all objects" do
+      it "freezes the router and its maps" do
         router.freeze
 
-        expect(router).to be_frozen
-        expect(router.flat_map).to be_frozen
-        expect(router.named_map).to be_frozen
-        expect(router.verb_map).to be_frozen
+        expect(router)
+          .to be_frozen
+        expect(router.flat_map)
+          .to be_frozen
+        expect(router.verb_map)
+          .to be_frozen
+        expect(router.named_map)
+          .to be_frozen
       end
     end
   end

data/spec/unit/namespace_spec.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Rutter
+  RSpec.describe Builder do
+    let(:router) { Rutter.new }
+
+    describe "namespace" do
+      it "support nested namespacees" do
+        router.namespace :species do
+          namespace :mammals do
+            get "/cats", to: "cats#index", as: :cats
+          end
+        end
+
+        route = router.flat_map.first
+
+        expect(route.path)
+          .to eq("/species/mammals/cats")
+        expect(route.endpoint)
+          .to eq(controller: "Species::Mammals::Cats", action: "index")
+        expect(router.named_map[:species_mammals_cats])
+          .to eq(route)
+      end
+    end
+  end
+end

data/spec/unit/route_spec.rb

@@ -2,80 +2,63 @@
 
 module Rutter
   RSpec.describe Route do
-    it "raises an error if request method is invalid" do
-      expect { Route.new("NONE", "/", ->(env) {}) }
-        .to raise_error(ArgumentError, "invalid verb: 'NONE'")
-    end
+    let(:endpoint) { ->(_) {} }
 
-    it "normalizes path" do
-      route = Route.new("GET", "//about////us/", ->(env) {})
-      expect(route.path).to eq("/about/us")
+    it "freezes the object" do
+      expect(Route.new("/", endpoint))
+        .to be_frozen
     end
 
-    describe "#expand" do
-      it "expand dynamic routes" do
-        route = Route.new("GET", "/books/:id(/:title)", -> {})
+    describe "#match?" do
+      it "returns true if path match" do
+        route = Route.new("/books", endpoint)
 
-        expect(route.expand(id: 54, title: "eloquent", include: [:foo]))
-          .to eq("/books/54/eloquent?include[]=foo")
-        expect(route.expand(id: 54, include: [:foo]))
-          .to eq("/books/54?include[]=foo")
-        expect(route.expand(id: 54, title: "eloquent"))
-          .to eq("/books/54/eloquent")
-        expect(route.expand(id: 54)).to eq("/books/54")
+        expect(route.match?(env_for("/books")))
+          .to be(true)
       end
 
-      it "expand static routes" do
-        route = Route.new("GET", "/books", -> {})
-        expect(route.expand(include: [:foo])).to eq("/books?include[]=foo")
-        expect(route.expand).to eq("/books")
-      end
-    end
+      it "returns false if path does not match" do
+        route = Route.new("/books", endpoint)
 
-    describe "#match?" do
-      it "matches non regexp" do
-        expect(Route.new("GET", "/books", -> {}).match?("/books"))
-          .to eq(true)
+        expect(route.match?(env_for("/")))
+          .to be(false)
       end
 
-      it "support named parameters" do
-        route = Route.new("GET", "/pages/:id(/:title)", -> {})
+      it "support using route constraints" do
+        route = Route.new("/books/:id", endpoint, id: /\d+/)
 
-        expect(route.match?("/pages/54/eloquent-ruby")).to eq(true)
-        expect(route.match?("/pages/54")).to eq(true)
-        expect(route.match?("/pages/54.rb")).to eq(false)
-        expect(route.match?("/pages")).to eq(false)
+        expect(route.match?(env_for("/books/82")))
+          .to be(true)
+        expect(route.match?(env_for("/books/pickaxe")))
+          .to be(false)
       end
+    end
 
-      it "support catch-all parameter" do
-        route = Route.new("GET", "/pages/*slug", -> {})
+    describe "#expand" do
+      let(:route) do
+        Route.new("/books/:book_id/reviews/:id", endpoint, {})
+      end
+
+      it "generates path from given args" do
+        expect(route.expand(book_id: 1, id: 2))
+          .to eq("/books/1/reviews/2")
+      end
 
-        expect(route.match?("/pages/54/eloquent-ruby")).to eq(true)
-        expect(route.match?("/pages/54/eloquent-ruby.rb")).to eq(true)
-        expect(route.match?("/pages/54/eloquent-ruby/with/more/parts")).to eq(true)
-        expect(route.match?("/pages")).to eq(false)
+      it "raises an error if a required argument is missing" do
+        expect { route.expand(book_id: 1) }
+          .to raise_error(ArgumentError, /cannot expand with keys/)
       end
     end
 
     describe "#params" do
       it "extract params" do
-        route = Route.new("GET", "/pages/:id(/:title)", -> {})
+        route = Route.new("/pages/:id(/:title)?", endpoint)
 
         expect(route.params("/pages/54/eloquent-ruby"))
           .to eq("id" => "54", "title" => "eloquent-ruby")
         expect(route.params("/pages/54"))
           .to eq("id" => "54", "title" => nil)
       end
-
-      it "returns nil if no match" do
-        route = Route.new("GET", "/books/:id", -> {})
-        expect(route.params("/posts/54")).to be_nil
-      end
-
-      it "returns empty array if no params present" do
-        route = Route.new("GET", "/books", -> {})
-        expect(route.params("/books")).to eq({})
-      end
     end
   end
 end