wayfarer 0.0.3 → 0.4.3

data/spec/routing/integration_spec.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require "spec_helpers"
+
+describe Wayfarer::Routing::DSL do
+  let(:route) { Wayfarer::Routing::RootRoute.new }
+
+  it "matches URLs" do
+    route.path "/"
+
+    result = route.invoke(Addressable::URI.parse("https://example.com/"))
+    expect(result).to be_a(Wayfarer::Routing::Result::Match)
+
+    result = route.invoke(Addressable::URI.parse("https://example.com/foo"))
+    expect(result).to be_a(Wayfarer::Routing::Result::Mismatch)
+  end
+
+  it "matches URLs" do
+    route.host "example.com", path: "/foo"
+
+    result = route.invoke(Addressable::URI.parse("https://example.com/foo"))
+    expect(result).to be_a(Wayfarer::Routing::Result::Match)
+  end
+
+  it "matches URLs" do
+    route.host "example.com", path: "/foo" do
+      query page: 1..10
+    end
+
+    result = route.invoke(Addressable::URI.parse("https://example.com/foo?page=4"))
+    expect(result).to be_a(Wayfarer::Routing::Result::Match)
+
+    result = route.invoke(Addressable::URI.parse("https://example.com/foo?page=11"))
+    expect(result).to be_a(Wayfarer::Routing::Result::Mismatch)
+
+    result = route.invoke(Addressable::URI.parse("https://example.com/foo"))
+    expect(result).to be_a(Wayfarer::Routing::Result::Mismatch)
+
+    result = route.invoke(Addressable::URI.parse("https://example.com?page=2"))
+    expect(result).to be_a(Wayfarer::Routing::Result::Mismatch)
+  end
+
+  it "matches URLs" do
+    route.host "example.com", path: "/foo" do
+      query page: 1..10
+    end
+
+    result = route.invoke(Addressable::URI.parse("https://example.com/foo?page=4"))
+    expect(result).to be_a(Wayfarer::Routing::Result::Match)
+
+    result = route.invoke(Addressable::URI.parse("https://example.com/foo?page=11"))
+    expect(result).to be_a(Wayfarer::Routing::Result::Mismatch)
+
+    result = route.invoke(Addressable::URI.parse("https://example.com/foo"))
+    expect(result).to be_a(Wayfarer::Routing::Result::Mismatch)
+
+    result = route.invoke(Addressable::URI.parse("https://example.com?page=2"))
+    expect(result).to be_a(Wayfarer::Routing::Result::Mismatch)
+  end
+
+  it "matches URLs" do
+    route.host "example.com" do
+      path "/contact"
+      path "/users/:id"
+    end
+
+    result = route.invoke(Addressable::URI.parse("https://example.com/contact"))
+    expect(result).to be_a(Wayfarer::Routing::Result::Match)
+
+    result = route.invoke(Addressable::URI.parse("https://example.com/contact/foo"))
+    expect(result).to be_a(Wayfarer::Routing::Result::Mismatch)
+
+    result = route.invoke(Addressable::URI.parse("https://example.com/users/123"))
+    expect(result).to be_a(Wayfarer::Routing::Result::Match)
+
+    result = route.invoke(Addressable::URI.parse("https://example.com/users/123/images"))
+    expect(result).to be_a(Wayfarer::Routing::Result::Mismatch)
+
+    result = route.invoke(Addressable::URI.parse("https://example.com/users"))
+    expect(result).to be_a(Wayfarer::Routing::Result::Mismatch)
+  end
+
+  it "matches URLs" do
+    route.host "example.com" do
+      path "/contact"
+      path "/users/:user_id" do
+        path "/images/:id"
+        path "/friends"
+      end
+    end
+
+    result = route.invoke(Addressable::URI.parse("https://example.com/contact"))
+    expect(result).to be_a(Wayfarer::Routing::Result::Match)
+
+    result = route.invoke(Addressable::URI.parse("https://example.com/users/123"))
+    expect(result).to be_a(Wayfarer::Routing::Result::Mismatch)
+
+    result = route.invoke(Addressable::URI.parse("https://example.com/users/123/images/23"))
+    expect(result).to be_a(Wayfarer::Routing::Result::Match)
+
+    result = route.invoke(Addressable::URI.parse("https://example.com/users/123/images/23/foo"))
+    expect(result).to be_a(Wayfarer::Routing::Result::Mismatch)
+
+    result = route.invoke(Addressable::URI.parse("https://example.com/users/123/friends"))
+    expect(result).to be_a(Wayfarer::Routing::Result::Match)
+
+    result = route.invoke(Addressable::URI.parse("https://example.com/users/123/foobar"))
+    expect(result).to be_a(Wayfarer::Routing::Result::Mismatch)
+  end
+end

data/spec/routing/matchers/custom_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "spec_helpers"
+
+describe Wayfarer::Routing::Matchers::Custom do
+  let(:url) { Addressable::URI.parse("http://example.com") }
+
+  describe "#match" do
+    context "with a block" do
+      context "when block is truthy" do
+        subject(:matcher) do
+          Wayfarer::Routing::Matchers::Custom.new ->(_) { true }
+        end
+
+        it "returns true" do
+          expect(matcher).to match(url)
+        end
+      end
+
+      context "when block is falsy" do
+        subject(:matcher) do
+          Wayfarer::Routing::Matchers::Custom.new ->(_) { false }
+        end
+
+        it "returns true" do
+          expect(matcher).not_to match(url)
+        end
+      end
+    end
+  end
+end

data/spec/routing/matchers/host_spec.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "spec_helpers"
+
+describe Wayfarer::Routing::Matchers::Host do
+  subject(:matcher) { Wayfarer::Routing::Matchers::Host.new(str_or_regexp) }
+
+  describe "#matches?" do
+    describe "String matching" do
+      let(:str_or_regexp) { "example.com" }
+
+      context "with matching URL" do
+        let(:url) { Addressable::URI.parse("http://example.com/foo/bar") }
+
+        it "returns true" do
+          expect(matcher).to match(url)
+        end
+      end
+
+      context "with mismatching URL" do
+        let(:url) { Addressable::URI.parse("http://google.com/bar/qux") }
+
+        it "returns false" do
+          expect(matcher).not_to match(url)
+        end
+      end
+    end
+
+    describe "RegExp matching" do
+      let(:str_or_regexp) { /example.com/ }
+
+      context "with matching URL" do
+        let(:url) { Addressable::URI.parse("http://sub.example.com") }
+
+        it "returns true" do
+          expect(matcher).to match(url)
+        end
+      end
+
+      context "with mismatching URL" do
+        let(:url) { Addressable::URI.parse("http://example.sub.com") }
+
+        it "returns false" do
+          expect(matcher).not_to match(url)
+        end
+      end
+    end
+  end
+end

data/spec/routing/matchers/path_spec.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "spec_helpers"
+
+describe Wayfarer::Routing::Matchers::Path, mri: true do
+  let(:route) { Wayfarer::Routing::RootRoute.new }
+  subject(:matcher) { Wayfarer::Routing::Matchers::Path.new(path, route) }
+
+  describe "#match?" do
+    context "with matching URL" do
+      let(:path) { "/{alpha}/{beta}" }
+
+      it "returns true" do
+        expect(matcher).to match(Addressable::URI.parse("http://example.com/foo/bar"))
+      end
+    end
+
+    context "with mismatching URL" do
+      let(:path) { "/{alpha}/{beta}" }
+
+      it "returns false" do
+        expect(matcher).not_to match(Addressable::URI.parse("http://example.com/foo"))
+      end
+    end
+
+    context "with mismatching URL" do
+      let(:path) { "/" }
+
+      it "returns false" do
+        expect(matcher).not_to match(Addressable::URI.parse("http://example.com/foo"))
+      end
+    end
+  end
+
+  describe "#params" do
+    let(:path) { "/{alpha}/{beta}" }
+
+    it "returns the correct parameters" do
+      url = Addressable::URI.parse("http://example.com/foo/bar")
+      expect(matcher.params(url)).to eq("alpha" => "foo", "beta" => "bar")
+    end
+  end
+end

data/spec/routing/matchers/query_spec.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require "spec_helpers"
+
+describe Wayfarer::Routing::Matchers::Query do
+  subject(:matcher) { Wayfarer::Routing::Matchers::Query.new(constraints) }
+
+  describe "String constraints" do
+    let(:constraints) { Hash[arg: "foo"] }
+
+    context "with matching query field value" do
+      let(:url) { Addressable::URI.parse("http://example.com?arg=foo") }
+
+      it "returns true" do
+        expect(matcher).to match(url)
+      end
+    end
+
+    context "with mismatching query field value" do
+      let(:url) { Addressable::URI.parse("http://example.com?arg=bar") }
+
+      it "returns false" do
+        expect(matcher).not_to match(url)
+      end
+    end
+  end
+
+  describe "Integer constraints" do
+    let(:constraints) { Hash[arg: 0] }
+
+    context "with matching query field value" do
+      let(:url) { Addressable::URI.parse("http://example.com?arg=0") }
+
+      it "returns true" do
+        expect(matcher).to match(url)
+      end
+    end
+
+    context "with mismatching query field value" do
+      let(:url) { Addressable::URI.parse("http://example.com?arg=1") }
+
+      it "returns false" do
+        expect(matcher).not_to match(url)
+      end
+    end
+
+    context "with non-numeric query field value" do
+      let(:url) { Addressable::URI.parse("http://example.com?arg=foo") }
+
+      it "returns false" do
+        expect(matcher).not_to match(url)
+      end
+    end
+  end
+
+  describe "Regexp constraints" do
+    let(:constraints) { Hash[arg: /foo/] }
+
+    context "with matching query field value" do
+      let(:url) { Addressable::URI.parse("http://example.com?arg=foo") }
+
+      it "returns true" do
+        expect(matcher).to match(url)
+      end
+    end
+
+    context "with mismatching query field value" do
+      let(:url) { Addressable::URI.parse("http://example.com?arg=bar") }
+
+      it "returns false" do
+        expect(matcher).not_to match(url)
+      end
+    end
+  end
+
+  describe "Range constraints" do
+    let(:constraints) { Hash[arg: 1..10] }
+
+    context "with matching query field value" do
+      let(:url) { Addressable::URI.parse("http://example.com?arg=5") }
+
+      it "returns true" do
+        expect(matcher).to match(url)
+      end
+    end
+
+    context "with mismatching query field value" do
+      let(:url) { Addressable::URI.parse("http://example.com?arg=11") }
+
+      it "returns false" do
+        expect(matcher).not_to match(url)
+      end
+    end
+
+    context "with non-numeric query field value" do
+      let(:url) { Addressable::URI.parse("http://example.com?arg=foo") }
+
+      it "returns false" do
+        expect(matcher).not_to match(url)
+      end
+    end
+  end
+
+  describe "Compound constraints" do
+    let(:constraints) do
+      Hash[foo: 1..5, bar: /baz/, qux: "zot", toto: 2]
+    end
+
+    context "with matching query field values" do
+      let(:url) { Addressable::URI.parse("http://example.com?foo=4&bar=bazqux&qux=zot&toto=2") }
+
+      it "returns true" do
+        expect(matcher).to match(url)
+      end
+    end
+
+    context "with mismatching query field values" do
+      let(:url) { Addressable::URI.parse("http://example.com?foo=bar&bar=qux&qux=6toto=0") }
+
+      it "returns false" do
+        expect(matcher).not_to match(url)
+      end
+    end
+  end
+
+  describe "#params" do
+    let(:constraints) do
+      Hash[foo: 1..5, bar: /baz/, qux: "zot", toto: 2]
+    end
+
+    it "returns the correct parameters" do
+      url = Addressable::URI.parse("http://example.com?foo=4&bar=bazqux&qux=zot&toto=2")
+      expect(matcher.params(url)).to \
+        eq("foo" => "4", "bar" => "bazqux", "qux" => "zot", "toto" => "2")
+    end
+  end
+end

data/spec/routing/matchers/scheme_spec.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "spec_helpers"
+
+describe Wayfarer::Routing::Matchers::Scheme do
+  describe "#match" do
+    subject(:matcher) { Wayfarer::Routing::Matchers::Scheme.new(:http) }
+
+    context "with matching URL" do
+      let(:url) { Addressable::URI.parse("http://example.com") }
+
+      it "returns true" do
+        expect(matcher).to match(url)
+      end
+    end
+
+    context "with mismatching URL" do
+      let(:url) { Addressable::URI.parse("https://example.com") }
+
+      it "returns true" do
+        expect(matcher).not_to match(url)
+      end
+    end
+  end
+end

data/spec/routing/{filetypes_rule_spec.rb → matchers/suffix_spec.rb}

@@ -1,38 +1,39 @@
 # frozen_string_literal: true
+
 require "spec_helpers"
 
-describe Wayfarer::Routing::FiletypesRule do
-  subject(:rule) { FiletypesRule.new([:png, :js]) }
+describe Wayfarer::Routing::Matchers::Suffix do
+  subject(:matcher) { Wayfarer::Routing::Matchers::Suffix.new(".png") }
 
-  describe "#matches?" do
-    context "with matching URI" do
+  describe "#match" do
+    context "with matching URL" do
       it "returns true" do
-        uris = %w(
+        urls = %w[
           http://example.com/foo.png
           https://example.com/a/b.png/c.png
           http://example.com/foobar.html.png
           https://example.com/foo.png/bar.png
-        ).map { |u| URI(u) }
+        ].map { |u| Addressable::URI.parse(u) }
 
-        uris.each do |uri|
-          expect(rule.matches?(uri)).to be true
+        urls.each do |url|
+          expect(matcher).to match(url)
         end
       end
     end
 
-    context "with mismatching URI" do
+    context "with mismatching URL" do
       it "returns false" do
-        uris = %w(
+        urls = %w[
           http://example.png
           http://example.com.png
           https://example.com/a/b.png/c
           http://example.com.html
           http://example.com/foobar.html
           https://example.com/foo.png/bar.png.html
-        ).map { |u| URI(u) }
+        ].map { |u| Addressable::URI.parse(u) }
 
-        uris.each do |uri|
-          expect(rule.matches?(uri)).to be false
+        urls.each do |url|
+          expect(matcher).not_to match(url)
         end
       end
     end

data/spec/routing/matchers/uri_spec.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "spec_helpers"
+
+describe Wayfarer::Routing::Matchers::URL do
+  subject(:matcher) do
+    Wayfarer::Routing::Matchers::URL.new("http://example.com/foo/bar")
+  end
+
+  describe "#match" do
+    context "with matching URL" do
+      let(:url) { Addressable::URI.parse("http://example.com/foo/bar") }
+
+      it "returns true" do
+        expect(matcher).to match(url)
+      end
+    end
+
+    context "with mismatching URL" do
+      let(:url) { Addressable::URI.parse("http://example.com/foo/qux") }
+
+      it "returns true" do
+        expect(matcher).not_to match(url)
+      end
+    end
+  end
+end

data/spec/routing/path_finder_spec.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "spec_helpers"
+
+describe Wayfarer::Routing::PathFinder do
+  let(:route) do
+    Wayfarer::Routing::RootRoute.new.to(:foobar) do
+      host "example.com", path: "/:a/:b"
+    end
+  end
+
+  subject(:result) { Wayfarer::Routing::PathFinder.result(route, Addressable::URI.parse(url)) }
+
+  describe "::result" do
+    context "with matching URL" do
+      let(:url) { "https://example.com/alpha/beta" }
+
+      it "returns a Match" do
+        expect(result).to be_a(Wayfarer::Routing::Result::Match)
+        expect(result.action).to be(:foobar)
+        expect(result.params).to eq("a" => "alpha", "b" => "beta")
+      end
+    end
+
+    context "with mismatching URL" do
+      let(:url) { "https://yahoo.com/alpha/zyklon" }
+
+      it "returns a Mismatch" do
+        expect(result).to be_a(Wayfarer::Routing::Result::Mismatch)
+      end
+    end
+  end
+end

data/spec/routing/root_route_spec.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "spec_helpers"
+
+describe Wayfarer::Routing::Route do
+  let(:route) { Wayfarer::Routing::RootRoute.new }
+
+  describe "#matcher" do
+    subject(:matcher) { route.matcher }
+
+    context "with child routes" do
+      before { route.host("http://google.com") }
+
+      it "returns true" do
+        %w[http://example.com http://w3c.org http://google.com].each do |url|
+          expect(matcher).to match(Addressable::URI.parse(url))
+        end
+      end
+    end
+
+    context "without child routes" do
+      it "returns false" do
+        %w[http://example.com http://w3c.org http://google.com].each do |url|
+          expect(matcher).not_to match(Addressable::URI.parse(url))
+        end
+      end
+    end
+  end
+end

data/spec/routing/route_spec.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "spec_helpers"
+
+describe Wayfarer::Routing::Route do
+  subject(:root) { Wayfarer::Routing::RootRoute.new }
+
+  describe "#invoke" do
+    context "with matching matchers" do
+      it "returns a Match" do
+        root.host "example.com", to: :overridden do
+          path "/:a/:b" do
+            to :overrider, query: { page: 42 }
+          end
+        end
+
+        result = root.invoke(Addressable::URI.parse("http://example.com/foo/bar?page=42"))
+
+        expect(result).to be_a(Wayfarer::Routing::Result::Match)
+        expect(result.action).to be(:overrider)
+        expect(result.params).to eq({
+                                      "a" => "foo",
+                                      "b" => "bar",
+                                      "page" => "42"
+                                    })
+      end
+    end
+
+    context "with mismatching matchers" do
+      it "returns a Mismatch" do
+        root.host "example.com", to: :overridden do
+          path "/:a/:b" do
+            query({ page: 42 }, { to: :overrider })
+          end
+        end
+
+        result = root.invoke(Addressable::URI.parse("http://w3c.org/foo/bar?page=42"))
+
+        expect(result).to be_a(Wayfarer::Routing::Result::Mismatch)
+      end
+    end
+  end
+end

data/spec/routing/router_spec.rb

@@ -1,67 +1,24 @@
 # frozen_string_literal: true
+
 require "spec_helpers"
 
 describe Wayfarer::Routing::Router do
-  subject(:router) { Router.new }
-
-  describe "#forbid" do
-    it "forbids URIs" do
-      router.forbid(host: "example.com")
-      expect(router.forbids?(URI("http://example.com"))).to be true
-
-      router.forbid { host "google.com" }
-
-      expect(router.forbids?(URI("http://google.com"))).to be true
-      expect(router.allows?(URI("http://google.com"))).to be false
-    end
-  end
-
-  describe "#route" do
-    context "with matching route" do
-      it "returns the registered payload and parameters" do
-        router.host "example.com", path: "/{barqux}", to: :foo
-
-        uri = URI("http://example.com/42")
-        method, params = router.route(uri)
-
-        expect(method).to be :foo
-        expect(params).to eq("barqux" => "42")
-      end
-    end
-
-    context "with mismatching route" do
-      it "returns false" do
-        router.host "example.com", path: "/{barqux}", to: :foo
-
-        uri = URI("http://google.com")
-
-        expect(router.route(uri)).to be false
+  subject(:router) do
+    described_class.new.tap do |router|
+      router.draw do |alpha, beta|
+        path alpha, to: :alpha
+        path beta, to: :beta
       end
     end
+  end
 
-    context "with forbidden URI" do
-      it "returns false" do
-        router.host "example.com", path: "/{barqux}", to: :foo
-        router.forbid.host "example.com"
-
-        uri = URI("http://example.com")
-
-        expect(router.route(uri)).to be false
-      end
-    end
-
-    context "with nested conflicting target actions" do
-      it "returns the expected parameters" do
-        router.host "example.com", to: :foo do
-          path "/{barqux}", to: :bar
-        end
-
-        uri = URI("http://example.com/42")
-        method, params = router.route(uri)
+  describe "#invoke" do
+    let(:url) { Addressable::URI.parse("https://example.com/alpha") }
 
-        expect(method).to be :bar
-        expect(params).to eq("barqux" => "42")
-      end
+    it "evaluates routes" do
+      result = router.invoke(url, %w[/alpha /beta])
+      expect(result).to be_a(Wayfarer::Routing::Result::Match)
+      expect(result.action).to be(:alpha)
     end
   end
 end