rack-domain 0.1.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: edff08a269f7b3cb74731b0da8ed93b1d8f05a4d
-  data.tar.gz: f1131a023969e1c0ff7448d69108a297e26c66ae
+  metadata.gz: 41d7ce04c47ae1bf25c2c8f2003de1da76ffaa85
+  data.tar.gz: 72db72f8e0140df322026d53236b0212f35c2ffd
 SHA512:
-  metadata.gz: 0e04ee83efd5e55eb3d3cf41714af42b8983cdadba0bc106544d8971bae1d511c8ce50cfe66445fb6983fa56a07685e9fc75cd112ff23935ab5e95fa84200f6d
-  data.tar.gz: ba157cc98443fbc789a90bbd9679e9d9833c9d0883fe97534207ee14f42f4249f4d25c9d74399f1a613223bd8b65beeaf5a49bfc381604959a2f4ca308f7a666
+  metadata.gz: a036dc1bd6474e768f1aa9be61b243db19d830c9b91214e96ae6145cc0fb76fcd4eb785ae4f4cc21e7bbd13d86d04b32270e72e5239610b8f1e35f9fd83090fd
+  data.tar.gz: 8d4320d153059937d0fc81b1d8aa2f50be82d077e2c77168d8773f4534bbc7bb7d9efa5a2dbe225fbcedf43a350708657c3c6c5e47efd98dfb046c2b2b6c0cf1

data/Gemfile

@@ -1,8 +1,2 @@
 source 'https://rubygems.org'
-
-gem 'rack-test',
-  '>= 0.4',
-  require: 'rack/test',
-  group: :test
-
 gemspec

data/README.md

@@ -5,6 +5,11 @@
 [![Coverage Status](https://coveralls.io/repos/whatyouhide/rack-domain/badge.png)](https://coveralls.io/r/whatyouhide/rack-domain)
 [![Inline docs](http://inch-ci.org/github/whatyouhide/rack-domain.svg?branch=master)](http://inch-ci.org/github/whatyouhide/rack-domain)
 
+`Rack::Domain` is a Rack middleware that enables you to intercept a request with
+a specific domain or subdomain (or regexp that matches a domain, actually) and
+route it to a specific application.
+
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -22,10 +27,59 @@ Or install it yourself as:
     $ gem install rack-domain
 
 
+## Usage
+
+`Rack::Domain` supports three kinds of filters in order to match a domain.
+
+- A string: it will match only if the string is exactly the same as the domain.
+- A regexp: it will match if the domain matches the regexp.
+- An array of strings and regexps: it will match if at least one of the elements
+    of the array matches (as described above) the domain.
+
+To decide where to dispatch the request if there's a match, you can use an
+existing Rack app through the `:run` option, or you can pass a block in which
+you can use the classic `use|run|map...` syntax. This works because the block is
+directly passed to a new instance of `Rack::Builder`.
+
+### Examples
+
+Using a regexp:
+
+``` ruby
+# Match the 'lobster' subdomain.
+use Rack::Domain, /^lobster\./, run: Rack::Lobster.new
+```
+
+Using a string:
+
+``` ruby
+# Match only if the current domain is github.com:
+use Rack::Domain, 'github.com', run: MyGitHubClone
+```
+
+Using an array of strings and regexps:
+
+``` ruby
+use Rack::Domain, ['lobst.er', /^lobster\./], run: Rack::Lobster.new
+```
+
+Using an on-the-fly app build with a `Rack::Builder`-style block:
+
+``` ruby
+use Rack::Domain, /^api/ do
+  use Rack::Logger
+  run MyApi
+end
+```
+
+
 ## Contributing
 
-Fork, make changes, commit, open Pull Request! Read the [GitHub guide to
-forking][forking] if you don't know how to.
+Fork, make changes, commit, open Pull Request, be awesome! Read the [GitHub
+guide to forking][forking] if you don't know how to.
+
+Also, issues are more than welcome! Open one if you find a bug, you have a
+suggestion or simply to ask a question.
 
 
 

data/lib/rack/domain.rb

@@ -4,20 +4,38 @@ require 'rack/domain/version'
 
 # This Rack middleware allows to intercept requests and route them to different
 # apps based on the domain (full, with subdomains and the TLD).
+#
+# @example Using a regexp
+#   # Match the 'lobster' subdomain.
+#   use Rack::Domain, /^lobster\./, run: Rack::Lobster.new
+# @example Using a string
+#   # Match only if the current domain is github.com:
+#   use Rack::Domain, 'github.com', run: MyGitHubClone
+# @example Using an array of strings and regexps
+#   use Rack::Domain, ['lobst.er', /^lobster\./], run: Rack::Lobster.new
+# @example Using an on-the-fly app build with a `Rack::Builder` block:
+#   use Rack::Domain, /^api/ do
+#     use Rack::Logger
+#     run MyApi
+#   end
 class Rack::Domain
   # Create a new instance of this middleware.
   # **Note** that this method is the method called by `Rack::Builder#use`.
   #
   # @param [#call] next_app The next app on the stack, filled automatically by
   #   Rack when building the middlware chain.
-  # @param [String, Regexp] filter The filter used to, well, filter the domain.
-  #   If `filter` is a `String`, it will be matched *at the beginning* of the
-  #   domain name; this is done so that it's easy to match subdomains and
-  #   domains without TLDs.
+  #
+  # @param [String, Regexp, Array<String, Regexp>] filter The filter used to,
+  #   well, filter the domain. If `filter` is a `String`, it will be matched as the
+  #   entire domain; if it's a regexp, it will be matched as a regexp. If it's
+  #   an array of strings and regexps, it will match if any of the elements of
+  #   the array matches the domain as specified above.
+  #
   # @param [Hash] opts An hash of options.
   # @option opts [#call, nil] :run The Rack app to run if the domain matches the
   #   filter. If you don't want to pass a ready application, you can pass a
   #   block with `Rack::Builder` syntax which will create a Rack app on-the-fly.
+  #
   # @raise [ArgumentError] if both a building block and an app to run were
   #   passed to this function.
   def initialize(next_app, filter, opts = {}, &block)
@@ -51,15 +69,23 @@ class Rack::Domain
 
   # Return `true` if the domain of the current request matches the given
   # `@filter`, `false` otherwise.
+  # @raise [ArgumentError] if the filter or array of filters aren't regexps or
+  #   strings.
   # @return [Boolean]
   def domain_matches?
-    case @filter
-    when Regexp
-      @filter =~ @domain
-    when String
-      @domain.start_with?(@filter)
-    else
-      fail 'The filter must be a Regexp or a String'
+    # Force the filter to be an array.
+    @filter = [@filter] unless @filter.is_a?(Array)
+
+    # Check if any of the elements of the `@filter` array matches the domain.
+    # The matching test is done based on the element's type.
+    @filter.any? do |flt|
+      if flt.is_a?(Regexp)
+        flt =~ @domain
+      elsif flt.is_a?(String)
+        flt == @domain
+      else
+        fail ArgumentError, 'The filters must be strings or regexps'
+      end
     end
   end
 end

data/lib/rack/domain/version.rb

@@ -4,6 +4,6 @@
 module Rack
   class Domain
     # The version of this gem.
-    VERSION = '0.1.1'
+    VERSION = '1.0.0'
   end
 end

data/rack-domain.gemspec

@@ -11,7 +11,7 @@ Gem::Specification.new do |spec|
   spec.homepage      = 'https://github.com/whatyouhide/rack-domain'
   spec.license       = 'MIT'
   spec.summary       = <<-SUMMARY
-    Rack middleware for dispatching Rack apps based on the domain'
+    Rack middleware for dispatching Rack apps based on the domain.
   SUMMARY
   spec.description   = <<-DESCRIPTION
     This Rack middleware allows you to run specific apps when the request
@@ -31,4 +31,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'minitest', '~> 5'
   spec.add_development_dependency 'minitest-reporters', '~> 1'
   spec.add_development_dependency 'coveralls', '~> 0.7'
+  spec.add_development_dependency 'rack-test', '>= 0.4'
 end

data/test/{subdomainer_test.rb → domain_test.rb}

@@ -2,11 +2,8 @@
 
 require_relative 'test_helper'
 
+LOBSTER = lambda { |env| [200, {}, ['Lobstericious']] }
 NOT_FOUNDER = lambda { |env| [404, {}, ['Error']] }
-LOBSTER = Rack::Builder.new do
-  map('/lobster') { run Rack::Lobster.new }
-  map('/') { run NOT_FOUNDER }
-end
 
 class DomainTest < Minitest::Test
   include Rack::Test::Methods
@@ -14,21 +11,28 @@ class DomainTest < Minitest::Test
   BASE_URL = 'http://example.com'
   BASE_URL_WITH_SUBDOMAIN = 'http://api.example.com'
 
-  def test_with_a_string
-    %w(api api.example api.example.com).each do |str|
-      set_app_to do
-        use Rack::Domain, str, run: Rack::Lobster.new
-        run NOT_FOUNDER
-      end
+  def test_with_a_single_specific_domain
+    set_app_to do
+      use Rack::Domain, 'api.example.com', run: LOBSTER
+      run NOT_FOUNDER
+    end
 
-      assert_dispatches_to_the_right_app
+    assert_dispatches_to_the_right_app
+  end
+
+  def test_with_an_array_of_domains
+    set_app_to do
+      use Rack::Domain, %w(api.a.b api.example.com), run: LOBSTER
+      run NOT_FOUNDER
     end
+
+    assert_dispatches_to_the_right_app
   end
 
-  def test_with_regexps
+  def test_with_single_regexps
     [/^api\./, /.+/, /example/, /\.com$/].each do |regexp|
       set_app_to do
-        use Rack::Domain, regexp, run: Rack::Lobster.new
+        use Rack::Domain, regexp, run: LOBSTER
         run NOT_FOUNDER
       end
 
@@ -36,13 +40,26 @@ class DomainTest < Minitest::Test
     end
   end
 
+  def test_with_an_array_of_regexps
+    set_app_to do
+      use Rack::Domain, [/api/, /test/], run: LOBSTER
+      run NOT_FOUNDER
+    end
+
+    assert_dispatches_to_the_right_app
+  end
+
+  def test_matching_with_a_mixed_array
+    set_app_to do
+      use Rack::Domain, [/api/, 'api.example.com'], run: LOBSTER
+      run NOT_FOUNDER
+    end
+  end
+
   def test_with_a_block
-    ['api', 'api.exam', /example/, /\.com$/].each do |filter|
+    ['api.example.com', /example/, /\.com$/].each do |filter|
       set_app_to do
-        use Rack::Domain, filter do
-          run Rack::Lobster.new
-        end
-
+        use(Rack::Domain, filter) { run LOBSTER }
         run NOT_FOUNDER
       end
 
@@ -50,27 +67,23 @@ class DomainTest < Minitest::Test
     end
   end
 
-  def test_rack_builder_dsl_extension
-    require 'rack/domain/dsl'
-
-    set_app_to do
-      domain 'api', run: Rack::Lobster.new
-      run NOT_FOUNDER
+  def test_argument_errors
+    # Both a block and a :run option.
+    assert_app_raises ArgumentError do
+      use(Rack::Domain, 'api', run: LOBSTER) { lob }
+      run LOBSTER
     end
-    assert_dispatches_to_the_right_app
 
-    set_app_to do
-      domain /^api\./, run: Rack::Lobster.new
-      run NOT_FOUNDER
+    # No filter specified.
+    assert_app_raises ArgumentError do
+      use(Rack::Domain, {}) { run LOBSTER }
+      run LOBSTER
     end
-    assert_dispatches_to_the_right_app
-  end
 
-  def test_argument_errors
+    # No arguments passed.
     assert_app_raises ArgumentError do
-      lob = Rack::Lobster.new
-      use(Rack::Domain, 'api', { run: Rack::Lobster.new }) { lob }
-      run lob
+      use(Rack::Domain)
+      run LOBSTER
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rack-domain
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Andrea Leopardi
@@ -94,6 +94,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.7'
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.4'
 description: |2
       This Rack middleware allows you to run specific apps when the request
       domain matches a given filter. The filter can be provided in a number of
@@ -112,10 +126,9 @@ files:
 - README.md
 - Rakefile
 - lib/rack/domain.rb
-- lib/rack/domain/dsl.rb
 - lib/rack/domain/version.rb
 - rack-domain.gemspec
-- test/subdomainer_test.rb
+- test/domain_test.rb
 - test/test_helper.rb
 homepage: https://github.com/whatyouhide/rack-domain
 licenses:
@@ -140,8 +153,8 @@ rubyforge_project:
 rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
-summary: Rack middleware for dispatching Rack apps based on the domain'
+summary: Rack middleware for dispatching Rack apps based on the domain.
 test_files:
-- test/subdomainer_test.rb
+- test/domain_test.rb
 - test/test_helper.rb
 has_rdoc: 

data/lib/rack/domain/dsl.rb

@@ -1,18 +0,0 @@
-# encoding: UTF-8
-
-require 'rack/domain'
-
-# This class is monkeypatched with the `#domain` method.
-class Rack::Builder
-  # Behaves just like `use Rack::Domain`, but with a simpler and clearer syntax.
-  #
-  # @param [String, Regexp] filter The filter used to match the domain.
-  # @param [Hash] opts An hash of options.
-  # @option opts [#call, nil] :run The app to run if the domain matches.
-  #
-  # @raise [ArgumentError] if no app to run or block were passed, or if both
-  #   were passed.
-  def domain(filter, opts = {}, &block)
-    use(Rack::Domain, filter, opts, &block)
-  end
-end