serviceworker-rails 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e15c642851a30d7cf973bc826cdd953de5248df2
-  data.tar.gz: ad30587132acd6fbf1052370d5dafa12f5d24edb
+  metadata.gz: 6c1a7fe0cb0777d62d399186270fd11a4965ed77
+  data.tar.gz: 24f12fd53135a6dc7a5ebbfaa8b73a39af9b5e1d
 SHA512:
-  metadata.gz: c695e3493724c49d99b7f8b72174057abd43ca4b73e6782706c80843efeca64c54512a535490f31a171b2f4e19175233b9a81f413fe5158d92b0e0ddaa3ef911
-  data.tar.gz: 2e4a8f6c092de36eb47fcaab1d0fb30bd21fa1244e8aa9b14dacf4757bcc87e5f0d7a9778c14d9af722b2002e1732188c5b5108a6f245fb2b208beb0d37c0048
+  metadata.gz: a38f837ac9dab05e34edbee772b98ca12959bed7851ad0ca7f8537eabc768cc5f5cac5a053c00605a3d72ace70c7520bd5bc0b1cda7a5dcd765f16193c5e65d6
+  data.tar.gz: 5db0e5eaf38682d447786a4950cc1e65b893052e5fe52b76016f4a5dc464ea82e059896df07f2144e79dbd13c023e2c13ccf4ce63bd1bb0254869e9ccfa2539a

data/.travis.yml

@@ -1,4 +1,6 @@
 language: ruby
 rvm:
+  - 2.1.8
+  - 2.2.5
   - 2.3.0
 before_install: gem install bundler -v 1.11.2

data/Gemfile

@@ -3,6 +3,10 @@ source 'https://rubygems.org'
 # Specify your gem's dependencies in serviceworker-rails.gemspec
 gemspec
 
-gem "pry-byebug", platforms: [:ruby_23]
-gem "guard"
-gem "guard-minitest"
+group :development, :test do
+  unless ENV["TRAVIS"]
+    gem "pry-byebug", platforms: [:ruby_23]
+    gem "guard"
+    gem "guard-minitest"
+  end
+end

data/README.md

@@ -1,11 +1,13 @@
 # ServiceWorker::Rails
 
-Integrates ServiceWorker scripts with the Rails asset pipeline.
+[![Build Status](https://travis-ci.org/rossta/serviceworker-rails.svg?branch=master)](https://travis-ci.org/rossta/serviceworker-rails)
+
+Use [Service Worker](https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API) with the Rails asset pipeline.
 
 ## Features
 
-* Leverages Rails asset pipeline to compile service worker scripts
-* Adds appropriate response headers to service worker scripts
+* Maps service worker endpoints to Rails assets
+* Adds appropriate response headers to service workers
 * Renders compiled source in production and development
 
 ## Installation
@@ -35,24 +37,20 @@ Sprockets JavaScript assets, like the example below, in `application.rb`.
 # application.rb
 
 config.serviceworker.routes.draw do
-  get "/basic-serviceworker.js"
+  match "/basic-serviceworker.js"
 
-  get "/proxied-serviceworker.js"
-    asset: "nested/asset/serviceworker.js"
+  match "/proxied-serviceworker.js" => "nested/asset/serviceworker.js"
 
-  get "/nested/serviceworker.js",
-    asset: "another/serviceworker.js"
+  match "/nested/serviceworker.js" => "another/serviceworker.js"
 
-  get "/header-serviceworker.js",
-    asset: "another/serviceworker.js",
+  match "/header-serviceworker.js" => "another/serviceworker.js",
     headers: { "X-Resource-Header" => "A resource" }
 
-  get "/*/serviceworker.js",
-    asset: "serviceworker.js"
+  match "/*/serviceworker.js" => "serviceworker.js"
 end
 ```
 
-`Serviceworker-Rails` with insert a `Cache-Control` header to instruct browsers
+`Serviceworker::Rails` with insert a `Cache-Control` header to instruct browsers
 not to cache your serviceworkers by default. You can customize the headers for all service worker routes if you'd like,
 such as adding the experimental [`Service-Worker-Allowed`](https://slightlyoff.github.io/ServiceWorker/spec/service_worker/#service-worker-allowed) header to set the allowed scope.
 

data/lib/serviceworker/middleware.rb

@@ -1,5 +1,10 @@
+# frozen_string_literal: true
 module ServiceWorker
   class Middleware
+    REQUEST_METHOD = "REQUEST_METHOD".freeze
+    GET = "GET".freeze
+    HEAD = "HEAD".freeze
+
     def initialize(app, opts = {})
       @app = app
       @opts = opts
@@ -8,12 +13,10 @@ module ServiceWorker
     end
 
     def call(env)
-      case env["REQUEST_METHOD"]
-      when "GET", "HEAD"
-        path = env["PATH_INFO"].chomp("/")
-        info("responding to #{path}")
-        route = @router.match_route(path)
-        return respond_to_route(route, env) if route
+      case env[REQUEST_METHOD]
+      when GET, HEAD
+        route_match = @router.match_route(env)
+        return respond_to_match(route_match, env) if route_match
       end
 
       @app.call(env)
@@ -27,14 +30,12 @@ module ServiceWorker
       }
     end
 
-    def respond_to_route(route, env)
-      status, headers, body = process_handler(route, env)
+    def respond_to_match(route_match, env)
+      env = env.merge("serviceworker.asset_name" => route_match.asset_name)
 
-      [status, headers.merge(@headers).merge(route.headers), body]
-    end
+      status, headers, body = handler.call(env)
 
-    def process_handler(route, env)
-      handler.call(env.merge("serviceworker.asset_name" => route.asset_name))
+      [status, headers.merge(@headers).merge(route_match.headers), body]
     end
 
     def info(msg)

data/lib/serviceworker/rails/handler.rb

@@ -1,3 +1,5 @@
+require "rack/file"
+
 module ServiceWorker
   module Rails
     class Handler
@@ -18,7 +20,7 @@ module ServiceWorker
       end
 
       def file_server
-        @file_server ||= ::Rack::File.new(::Rails.root.join("public"))
+        @file_server ||= ::Rack::File.new(::Rails.public_path)
       end
 
       def config

data/lib/serviceworker/rails/version.rb

@@ -1,5 +1,5 @@
 module ServiceWorker
   module Rails
-    VERSION = "0.2.0"
+    VERSION = "0.3.0"
   end
 end

data/lib/serviceworker/route.rb

@@ -1,22 +1,32 @@
 module ServiceWorker
   class Route
-    attr_reader :path, :options
+    attr_reader :path_pattern, :asset_pattern, :options
 
-    def initialize(path, options = {})
-      @path = path
-      @options = options
-
-      @pattern = compile(path)
+    RouteMatch = Struct.new(:path, :asset_name, :headers) do
+      def to_s
+        asset_name
+      end
     end
 
-    def match?(path)
-      @pattern =~ path
+    def initialize(path_pattern, asset_pattern = nil, options = {})
+      if asset_pattern.is_a?(Hash)
+        options = asset_pattern
+        asset_pattern = nil
+      end
+
+      @path_pattern = path_pattern
+      @asset_pattern = asset_pattern || options[:asset] || path_pattern
+      @options = options
     end
 
-    def asset_name
-      @options.fetch(:asset, @path.gsub(%r{^/}, ""))
-    rescue NoMethodError
-      raise RouteError, "Cannot determine asset name from #{path.inspect}. Please specify the :asset option for this path."
+    def match(path)
+      if path.to_s.strip.empty?
+        raise ArgumentError.new("path is required")
+      end
+
+      asset = resolver.call(path) or return nil
+
+      RouteMatch.new(path, asset, headers)
     end
 
     def headers
@@ -25,24 +35,92 @@ module ServiceWorker
 
     private
 
-    def compile(path)
-      if path.respond_to?(:to_str)
-        special_chars = %w[. + ( )]
-        pattern = path.to_str.gsub(/([\*#{special_chars.join}])/) do |match|
-          case match
-          when "*"
-            "(.*?)"
-          when *special_chars
-            Regexp.escape(match)
+    def resolver
+      @resolver ||= AssetResolver.new(path_pattern, asset_pattern)
+    end
+
+    class AssetResolver
+      PATH_INFO = 'PATH_INFO'.freeze
+      DEFAULT_WILDCARD_NAME = :paths
+      WILDCARD_PATTERN = /\/\*([^\/]*)/.freeze
+      NAMED_SEGMENTS_PATTERN = /\/([^\/]*):([^:$\/]+)/.freeze
+      LEADING_SLASH_PATTERN = /^\//
+      INTERPOLATION_PATTERN = Regexp.union(
+        /%%/,
+        /%\{(\w+)\}/, # matches placeholders like "%{foo}"
+      )
+
+      attr_reader :path_pattern, :asset_pattern
+
+      def initialize(path_pattern, asset_pattern)
+        @path_pattern = path_pattern
+        @asset_pattern = asset_pattern
+      end
+
+      def call(path)
+        if path.to_s.strip.empty?
+          raise ArgumentError.new("path is required")
+        end
+
+        captures = path_captures(regexp, path) or return nil
+
+        interpolate_captures(asset_pattern, captures)
+      end
+
+      private
+
+      def regexp
+        @regexp ||= compile_regexp(path_pattern)
+      end
+
+      def compile_regexp(pattern)
+        Regexp.new("\\A#{compiled_source(pattern)}\\Z")
+      end
+
+      def compiled_source(pattern)
+        if pattern_match = pattern.match(WILDCARD_PATTERN)
+          @wildcard_name = if pattern_match[1].to_s.strip.empty?
+                             DEFAULT_WILDCARD_NAME
+                           else
+                             pattern_match[1].to_sym
+                           end
+          pattern.gsub(WILDCARD_PATTERN,'(?:/(.*)|)')
+        else
+          p = if pattern_match = pattern.match(NAMED_SEGMENTS_PATTERN)
+                pattern.gsub(NAMED_SEGMENTS_PATTERN, '/\1(?<\2>[^.$/]+)')
+              else
+                pattern
+              end
+          p + '(?:\.(?<format>.*))?'
+        end
+      end
+
+      def path_captures(regexp, path)
+        return nil unless path_match = path.match(regexp)
+        params = if @wildcard_name
+                   { @wildcard_name => path_match[1].to_s.split('/') }
+                 else
+                   Hash[path_match.names.map(&:to_sym).zip(path_match.captures)]
+                 end
+        params.delete(:format) if params.has_key?(:format) && params[:format].nil?
+        params
+      end
+
+      def interpolate_captures(string, captures)
+        string.gsub(INTERPOLATION_PATTERN) do |match|
+          if match == '%%'
+            '%'
           else
-            "([^/?&#]+)"
+            key = ($1 || $2).to_sym
+            value = if captures.key?(key)
+                      Array(captures[key]).join("/")
+                    else
+                      raise "Interpolation error: #{key} not captured in #{captures.inspect}"
+                    end
+            value = value.call(captures) if value.respond_to?(:call)
+            $3 ? sprintf("%#{$3}", value) : value
           end
-        end
-        /^#{pattern}$/
-      elsif path.respond_to?(:match)
-        path
-      else
-        raise TypeError, path
+        end.gsub(LEADING_SLASH_PATTERN, "")
       end
     end
   end

data/lib/serviceworker/router.rb

@@ -1,5 +1,8 @@
+# frozen_string_literal: true
 module ServiceWorker
   class Router
+    PATH_INFO = "PATH_INFO".freeze
+
     def self.default
       new.draw_default
     end
@@ -28,19 +31,31 @@ module ServiceWorker
       draw { get "/serviceworker.js" }
     end
 
-    def get(path, options = {})
-      Route.new(path, options).tap do |route|
+    def match(path, *args)
+      if path.is_a?(Hash)
+        opts = path.to_a
+        path, asset = opts.shift
+        args = [asset, opts.to_h]
+      end
+
+      Route.new(path, *args).tap do |route|
         @routes << route
       end
     end
+    alias get match
 
     def any?
       @routes.any?
     end
 
-    def match_route(path)
-      @routes.detect { |r| r.match?(path) }
+    def match_route(env)
+      path = env[PATH_INFO]
+      @routes.each do |route|
+        if match = route.match(path)
+          return match
+        end
+      end
+      nil
     end
   end
-
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: serviceworker-rails
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Ross Kaffenberger
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-04-25 00:00:00.000000000 Z
+date: 2016-05-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: railties
@@ -145,7 +145,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.2.3
 signing_key: 
 specification_version: 4
 summary: ServiceWorker for Rails 3+