roda-sprockets 1.0.2 → 2.0.0rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 64c7457f4f6cca73af4aede33d7fbbe2922aac43a05a399af1658a2fa54250ec
-  data.tar.gz: d14d895b6704ae71b20958df0e3d0fa054054b25862b529d6b94b15a6acbbb3d
+  metadata.gz: 508fedb44f1daee79f32b2ef1746fb5a266aa771465dc44b42a9d2de03787d6a
+  data.tar.gz: 15678eedb2c7d2aa7d5e8c1136dd2b16c77d4336514e689875488a7ec593e934
 SHA512:
-  metadata.gz: 4e2fa406bc9c3d22c508e683bbe65e5424361b3cf73c6c10e09f470c2fe43bd288789a6c11df8d5c3deea7d3f28ece35cfc609f6942cbe2046309384aae05535
-  data.tar.gz: 565f7f00f965f808cde41a95c9c1309cbfea91068f4f9090760b0d47e58bef41966855836c32f8981db72322f899aee32d109de046d3327d47a378330b330b92
+  metadata.gz: eac697f7e01b05019e19a48704088910ceb1451ad2d6e40dccfc3ee8d8c67ef3b301d61876ca6089b4ce8454f19a1b02afbe3065abd812fdd804017188ddd838
+  data.tar.gz: c25b68ac51d50b091f398a5d98780f15987c20643535e289ed034d60929229ca0af556545dd6268981c83921dd763080c1a572306e5ef009161c37c20b57716c

data/.github/workflows/rake.yml

@@ -0,0 +1,32 @@
+name: rake
+
+on:
+  push:
+    branches:
+      - master
+      - "*-stable"
+      - "*/ci-check"
+  pull_request: {}
+
+jobs:
+  rspec:
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby-version: ['2.6', '2.7', '3.0']
+        os: ['ubuntu-latest', 'windows-latest', 'macos-latest']
+    
+    runs-on: ${{ matrix.os }}
+
+    env:
+      CI: 'true'
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby-version }}
+        bundler-cache: true # runs 'bundle install' and caches installed gems automatically
+    - name: Run tests
+      run: bundle exec rake

data/.gitignore

@@ -1,12 +1,13 @@
 /.bundle/
 /.yardoc
-/Gemfile.lock
+Gemfile.lock
 /_yardoc/
 /coverage/
 /doc/
 /pkg/
 /spec/reports/
 /tmp/
+/vendor/
 *.bundle
 *.so
 *.o

data/.rspec

@@ -0,0 +1 @@
+--require spec_helper

data/CHANGELOG.md

@@ -0,0 +1,29 @@
+v2.0.0
+
+- :debug argument now defaults to true, if RACK_ENV is development, false
+  otherwise - also false in rake tasks (#10)
+- add sprockets_env class method, so you can shorten code like
+  `App.sprockets_options[:sprockets]` to just `App.sprockets_env` (#11)
+
+v1.1.0
+
+- Fix the Rack::Lint issue (#1)
+- :public_path argument to receive a default value (#7)
+- Roda::RodaPlugins::Sprockets::Task to superclass SprocketsTask (#6)
+- The debug logic now depends on :debug argument, not environment (#4)
+
+v1.0.2
+
+- :root argument to select a default argument more robustly (#2)
+
+v1.0.1
+
+- New :cache argument to plugin configuration
+
+v1.0.0
+
+- Sprockets 4.0 support
+
+v0.0.11
+
+- Support polyinstantiation, improve Opal support

data/Gemfile

@@ -2,3 +2,16 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in roda-sprocket_assets.gemspec
 gemspec
+
+# For rspec:
+gem "rspec"
+gem "opal"
+gem "opal-sprockets"
+gem "sassc"
+gem "uglifier"
+# Until janbiedermann's Windows paths patch is released, we are using git ref:
+# https://github.com/rubycdp/ferrum/commit/5beca76588d1544026eb8b8ee841f305803c67e5
+# Also, my patch that captures stacktraces should be merged:
+# https://github.com/hmdne/ferrum/commit/fbc74b7ca7b670d29cc53a2d779470a05c60ef9d
+gem "ferrum", github: "hmdne/ferrum", ref: "capture-stacktrace"
+gem "puma"

data/LICENSE.txt

@@ -1,5 +1,5 @@
 Copyright (c) 2015 cj
-Copyright (c) 2020 hmdne
+Copyright (c) 2020-2021 hmdne and opal-sprockets contributors
 
 MIT License
 

data/README.md

@@ -22,35 +22,44 @@ And then execute:
 ```ruby
 class App < Roda
    plugin :sprockets, precompile: %w(site.js site.css),
-                      public_path: 'public/',
                       opal: true,
-                      debug: true
    plugin :public
 
    route do |r|
      r.public
-     r.sprockets
-   end     
+     r.sprockets if ENV['RACK_ENV'] == 'development'
+   end
 end
 ```
 
 ### Parameters for the plugin:
 
 * `precompile` - an array of files that you want to precompile
-* `prefix` (relative to the `root`, which is `app.opts[:root]` by default,
-  but also supports absolute paths) - an array of directories where your
-  assets are located, by default: `%w(assets vendor/assets)`.
-* `root` - a filesystem root directory of your app. By default, `app.opts[:root]`.
-* `public_path` - filesystem path to your `public` directory, for all your
-  precompilation needs. (REQUIRED)
+* `prefix` (relative to the `root`, which is `app.opts[:root]` by default) -
+  an array of directories where your assets are located, by default:
+  `%w(assets vendor/assets)`.
+  * Here, an element of the array can be an absolute path instead of relative.
+  * If an element ends with `/`, it will use assets directly in a given
+    subdirectory.
+  * If it doesn't end with `/` (which is by default) if will be equivalent to
+    `value/*`, which means, that assets will be loaded for instance from
+    `assets/javascripts` and `assets/stylesheets`, but not directly from `assets`.
+  * An element can contain glob characters.
+* `root` - a filesystem root directory of your app. By default, same as
+  `app.opts[:root]`, that is: `Dir.pwd`.
+* `public_path` - filesystem path to a place, where precompiled assets will be
+  stored, by default: `public/assets` (it should be a directory from which `:public`
+  plugin takes files + `path_prefix`)
 * `path_prefix` - a Roda prefix of your assets directory. By default: `/assets`
 * `protocol` - either :http (default) or :https.
-* `css_compressor`, `js_compressor` - pick a compressor of your choice.
+* `css_compressor`, `js_compressor` - pick a compressor of your choice (respected
+  only if `debug` is false)
 * `host` - for hosting your assets on a different server
 * `digest` (bool) - digest your assets for unique filenames, default: true
 * `opal` (bool) - Opal support, default: false
-* `debug` (bool) - debug mode, default: false
-* `cache` - a `Sprockets::Cache` instance
+* `debug` (bool) - debug mode, default: true if RACK_ENV is development,
+  false otherwise (in rake tasks it's false too)
+* `cache` - a `Sprockets::Cache` instance, default: nil (no cache)
 
 ### Templates:
 
@@ -88,15 +97,39 @@ $document.body << DOM {
 ```
 
 You will need to tell Opal to load this file. Add this in your template
-after everything has been loaded or somewhere else:
+after everything has been loaded (after your `javascript_tag` call, it is
+needed too!):
 
-```html
+```erb
 <%= opal_require 'site' %>
 ```
 
 Note that it won't be needed for plain Javascript use, only Opal needs that
 line.
 
+### Caching:
+
+To speed up page loads during development, you can enable cache. Be warned,
+there are some caveats with how Sprockets cache works. This will improve your
+experience, but be prepared for some rough edges.
+
+To enable memory cache, add an argument to your plugin config:
+
+```ruby
+cache: Sprockets::Cache::MemoryStore.new(65536)
+```
+
+To enable filesystem cache, for it to persist across application restarts,
+add an argument to your plugin config:
+
+```ruby
+cache: Sprockets::Cache::FileStore.new("var/cache/")
+```
+
+Remember: with filesystem cache problems may happen if you, for instance,
+update your Gems. You will then have to remove the cache for it to get
+repopulated.
+
 ### Rake precompilation tasks:
 
 In your Rakefile:
@@ -110,6 +143,27 @@ Roda::RodaPlugins::Sprockets::Task.define!(App)
 
 And launch: `rake assets:precompile` or `rake assets:clean`
 
+### Sprockets extended configuration:
+
+You can configure your environment directly by accessing a method `sprockets_env`
+(which is a `Sprockets::Environment`) on your `App` class.
+
+For instance, to enable Brotli with [sprockets-exporters_pack](https://github.com/hansottowirtz/sprockets-exporters_pack)
+you will need to either add this code inside your `App` class:
+
+```ruby
+sprockets_env.register_exporter %w(text/css application/javascript image/svg+xml), Sprockets::ExportersPack::BrotliExporter
+```
+
+Or at some other point:
+
+```ruby
+App.sprockets_env.register_exporter %w(text/css application/javascript image/svg+xml), Sprockets::ExportersPack::BrotliExporter
+```
+
+Do note, that some extensions, like for example [opal-optimizer](https://github.com/hmdne/opal-optimizer)
+won't need any configuration at all beside `require "opal/optimizer/sprockets"`.
+
 ## Contributing
 
 1. Fork it ( https://github.com/hmdne/roda-sprockets/fork )

data/Rakefile

@@ -1,2 +1,6 @@
 require "bundler/gem_tasks"
+require "rspec/core/rake_task"
 
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/examples/opal-doc/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+gem "roda-sprockets", path: "../.."
+gem "opal-sprockets"
+gem "puma"
+gem "rake"

data/examples/opal-doc/README.md

@@ -0,0 +1,4 @@
+This is an example found in `opal` repository in `docs/roda-sprockets.md`.
+
+It describes how to create the simplest application with roda, roda-sprockets
+and opal.

data/examples/opal-doc/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/setup"
+require "roda/plugins/sprockets_task"
+
+require_relative "app"
+
+Roda::RodaPlugins::Sprockets::Task.define!(App)

data/examples/opal-doc/app.rb

@@ -0,0 +1,25 @@
+require 'roda'
+
+class App < Roda
+   plugin :sprockets, precompile: %w(application.js),
+                      prefix: %w(app/),
+                      opal: true
+   plugin :public
+
+   route do |r|
+     r.public
+     r.sprockets if ENV['RACK_ENV'] == 'development'
+
+     r.root do
+       <<~END
+         <!doctype html>
+         <html>
+           <head>
+             #{ javascript_tag 'application' }
+             #{ opal_require 'application' }
+           </head>
+         </html>
+       END
+     end
+   end     
+end

data/examples/opal-doc/app/application.rb

@@ -0,0 +1,3 @@
+require 'opal'
+
+puts "wow, running ruby!"

data/examples/opal-doc/config.ru

@@ -0,0 +1,3 @@
+require_relative "app"
+
+run App.app

data/examples/opal-exception/Gemfile

@@ -0,0 +1,8 @@
+source "https://rubygems.org"
+
+gem "roda-sprockets", path: "../.."
+gem "opal"
+gem "opal-sprockets"
+gem "puma"
+gem "rake"
+gem "uglifier"

data/examples/opal-exception/README.md

@@ -0,0 +1 @@
+This example drops an exception. It's for a test of source maps.

data/examples/opal-exception/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/setup"
+require "roda/plugins/sprockets_task"
+
+require_relative "app"
+
+Roda::RodaPlugins::Sprockets::Task.define!(App)

data/examples/opal-exception/app.rb

@@ -0,0 +1,26 @@
+require 'roda'
+
+class App < Roda
+   plugin :sprockets, precompile: %w(application.js),
+                      prefix: %w(app/),
+                      js_compressor: :uglify,
+                      opal: true
+   plugin :public
+
+   route do |r|
+     r.public
+     r.sprockets if ENV['RACK_ENV'] == 'development'
+
+     r.root do
+       <<~END
+         <!doctype html>
+         <html>
+           <head>
+             #{ javascript_tag 'application' }
+             #{ opal_require 'application' }
+           </head>
+         </html>
+       END
+     end
+   end     
+end

data/examples/opal-exception/app/application.rb

@@ -0,0 +1,16 @@
+require 'opal'
+
+def a
+  b
+end
+
+def b
+  2 + 2 == 5
+  c
+end
+
+def c
+  nomethoderror
+end
+
+a

data/examples/opal-exception/config.ru

@@ -0,0 +1,3 @@
+require_relative "app"
+
+run App.app

data/examples/sass/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+gem "roda-sprockets", path: "../.."
+gem "sassc"
+gem "puma"
+gem "rake"

data/examples/sass/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/setup"
+require "roda/plugins/sprockets_task"
+
+require_relative "app"
+
+Roda::RodaPlugins::Sprockets::Task.define!(App)

data/examples/sass/app.rb

@@ -0,0 +1,23 @@
+require 'roda'
+
+class App < Roda
+   plugin :sprockets, precompile: %w(application.css)
+   plugin :public
+
+   route do |r|
+     r.public
+     r.sprockets if ENV['RACK_ENV'] == 'development'
+
+     r.root do
+       <<~END
+         <!doctype html>
+         <html>
+           <head>
+             #{ stylesheet_tag 'application' }
+           </head>
+         </html>
+       END
+     end
+   end
+end
+

data/examples/sass/assets/css/application.scss

@@ -0,0 +1,3 @@
+html, body {
+  background-color: green;
+}

data/examples/sass/config.ru

@@ -0,0 +1,3 @@
+require_relative "app"
+
+run App.app

data/lib/roda/plugins/sprockets.rb

@@ -10,7 +10,7 @@ class Roda
         precompile:     %w(app.js app.css *.png *.jpg *.svg *.eot *.ttf *.woff *.woff2),
         prefix:         %w(assets vendor/assets),
         root:           false,
-        public_path:    false,
+        public_path:    "public/assets/",
         path_prefix:    "/assets",
         protocol:       :http,
         css_compressor: nil,
@@ -18,14 +18,10 @@ class Roda
         host:           nil,
         digest:         true,
         opal:           false,
-        debug:          false,
+        debug:          nil,
         cache:          nil,
       }.freeze
 
-      def self.load_dependencies(app, _opts = nil)
-        app.plugin :environments
-      end
-
       def self.configure(app, plugin_options = {})
         if app.opts[:sprockets]
           app.opts[:sprockets].merge!(plugin_options)
@@ -39,7 +35,13 @@ class Roda
           options[:root] = app.opts[:root] || Dir.pwd
         end
 
-        %i(root public_path).each { |type| raise "#{type} needs to be set." unless options[type] }
+        if options[:debug].nil?
+          if ENV['RACK_ENV'] == 'development'
+            options[:debug] = true
+          else
+            options[:debug] = false
+          end
+        end
 
         # opal-sprockets registers engines when required, but if we create Sprockets::Environment before
         # requiring that, they don't get registered
@@ -85,9 +87,9 @@ class Roda
         options[:sprockets_helpers].prefix      = options[:path_prefix] unless options[:path_prefix].nil?
         options[:sprockets_helpers].debug       = options[:debug]
 
-        app.configure :staging, :production do
+        unless options[:debug]
           options[:sprockets].css_compressor = options[:css_compressor] unless options[:css_compressor].nil?
-          options[:sprockets].js_compressor  = options[:js_compressor] unless options[:js_compressor].nil?
+          options[:sprockets].js_compressor  = options[:js_compressor] unless options[:js_compressor].nil?  
 
           options[:sprockets_helpers].manifest   = ::Sprockets::Manifest.new(options[:sprockets], options[:public_path])
           options[:sprockets_helpers].protocol   = options[:protocol]
@@ -100,6 +102,10 @@ class Roda
           opts[:sprockets]
         end
 
+        def sprockets_env
+          sprockets_options[:sprockets]
+        end
+
         def sprockets_regexp
           %r{#{sprockets_options[:sprockets_helpers].prefix[1..-1]}/(.*)}
         end
@@ -138,15 +144,20 @@ class Roda
 
             status, headers, response = options[:sprockets].call env_sprockets
 
-            # Appease Rack::Lint
-            if (300..399).include? status
-              headers.delete("Content-type")
-            end
-
             scope.response.status = status
             scope.response.headers.merge! headers
 
-            response.is_a?(Array) ? response.join('\n') : response.to_s
+            case response
+            when nil, []
+              # Empty response happens for example when 304 Not Modified happens.
+              # We want to return nil in this case.
+              # (See: https://github.com/hmdne/roda-sprockets/issues/1)
+              nil
+            when Array
+              response.join
+            else
+              response.to_s
+            end
           end
         end
       end

data/lib/roda/plugins/sprockets_task.rb

@@ -5,20 +5,44 @@ require 'rake/sprocketstask'
 class Roda
   module RodaPlugins
     module Sprockets
-      class Task < Rake::TaskLib
+      class Task < Rake::SprocketsTask
         def initialize(app_klass)
+          if app_klass.class != Class
+            raise "#{app_klass} is not a Class"
+          elsif !app_klass.ancestors.map(&:name).include? "Roda"
+            raise "#{app_klass} doesn't inherit Roda"
+          elsif !app_klass.respond_to? :sprockets_options
+            raise "#{app_klass} doesn't load 'plugin :sprockets` - we can build nothing from it"
+          end
+
+          @app_klass = app_klass
+          super() { update_values }
+        end
+
+        def update_values
+          @environment = sprockets_options[:sprockets]
+          @output = sprockets_options[:public_path]
+          @assets = sprockets_options[:precompile]
+        end
+
+        def sprockets_options
+          @app_klass.sprockets_options
+        end
+
+        def define
           namespace :assets do
             desc "Precompile assets"
             task :precompile do
-              options = app_klass.sprockets_options
-              environment = options[:sprockets]
-              manifest = ::Sprockets::Manifest.new(environment.index, options[:public_path])
-              manifest.compile(options[:precompile])
+              with_logger do
+                manifest.compile(assets)
+              end
             end
 
             desc "Clean assets"
             task :clean do
-              FileUtils.rm_rf(app_klass.sprockets_options[:public_path])
+              with_logger do
+                manifest.clobber
+              end
             end
           end
         end

data/roda-sprockets.gemspec

@@ -4,7 +4,7 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |spec|
   spec.name          = "roda-sprockets"
-  spec.version       = '1.0.2'
+  spec.version       = '2.0.0rc1'
   spec.authors       = ["cj", "hmdne"]
   spec.email         = ["cjlazell@gmail.com"]
   spec.summary       = %q{Use sprockets to serve assets in roda.}

data/spec/assets/css/scss_css.scss

@@ -0,0 +1,7 @@
+@mixin scss($this, $is, $scss) {
+  content: "#{$this} #{$is} #{$scss}"
+}
+
+body {
+  @include scss(This, is, SCSS);
+}

data/spec/assets/css/scss_css_with_erb.scss.erb

@@ -0,0 +1,13 @@
+<%=
+  mixin = "@mixin"
+  incl = "@include"
+  <<~EOF
+    #{mixin} scss($this, $is, $scss) {
+      content: "\#{$this} \#{$is} \#{$scss}"
+    }
+
+    body {
+      #{incl} scss(This, is, ERBSCSS);
+    }
+  EOF
+%>

data/spec/assets/css/scss_css_with_imports.scss

@@ -0,0 +1 @@
+@import "scss_css";

data/spec/assets/css/simple_css.css

@@ -0,0 +1 @@
+body { content: "Simple CSS"; }

data/spec/assets/js/opal_js.rb

@@ -0,0 +1,4 @@
+class Test
+end
+
+Test.new

data/spec/assets/js/opal_js_with_erb.rb.erb

@@ -0,0 +1,10 @@
+<%=
+  classname = "TestERB"
+
+  <<~EOF
+    class #{classname}
+    end
+    
+    #{classname}.new
+  EOF
+%>

data/spec/assets/js/opal_js_with_requires.rb

@@ -0,0 +1 @@
+require "opal_js"

data/spec/assets/js/simple_js.js

@@ -0,0 +1 @@
+alert("Simple JS");

data/spec/examples_spec.rb

@@ -0,0 +1,141 @@
+require "ferrum"
+
+def sigterm(pid)
+  if Gem.win_platform?
+    system("taskkill /F /pid #{pid}")
+  else
+    Process.kill("TERM", pid)
+    Process.wait(pid)
+  end
+rescue Errno::ECHILD
+  # Ignore
+end
+
+def free_port
+  $free_port ||= 19900
+  $free_port += 1
+  $free_port
+end
+
+browser_options = {
+  timeout: 15,
+  process_timeout: 20,
+  js_errors: true,
+  browser_options: {
+    'no-sandbox': nil,
+    'auto-open-devtools-for-tabs': nil
+  }
+}
+
+RSpec.describe "Example" do
+  Dir[__dir__+"/../examples/*"].each do |example|
+    example_name = File.basename(example)
+
+    example_specific = proc do |browser, debug, error|
+      case example_name
+      when "opal-doc"
+        browser.evaluate("typeof(Opal.Kernel.$puts)").should be == "function"
+      when "opal-exception"
+        error.should_not be_nil
+        functions = error.stack_trace["callFrames"].map { |i| i["functionName"] }
+        if debug
+          functions.should include "$$a"
+          functions.should include "$$b"
+          functions.should include "$$c"
+        else
+          # We minify this example, so functions should be mangled
+          functions.should_not include "$$a"
+          functions.should_not include "$$b"
+          functions.should_not include "$$c"
+        end
+        # Nevertheless, "Opal.modules.application" should stay unmangled.
+        functions.should include "Opal.modules.application"
+        # How can we now test that source maps work? The browser doesn't help us...
+      when "sass"
+        browser.evaluate("window.getComputedStyle(document.body).backgroundColor").should be == "rgb(0, 128, 0)"
+      end
+    end
+
+    context example_name do
+      it "works in development mode" do
+        Dir.chdir example do
+          Bundler.with_unbundled_env do
+            if ENV.key? 'CI'
+              # Ensure we will reuse the cached gems
+              system("bundle config --local path #{__dir__+"/../vendor/bundle"}")
+            end
+
+            system("bundle install").should be true
+
+            begin
+              port = free_port
+              pid = spawn("bundle exec rackup -p#{port}")
+              sleep 1
+
+              begin
+                browser = Ferrum::Browser.new(**browser_options)
+                browser.go_to("http://localhost:#{port}/")
+                browser.network.wait_for_idle
+
+                # Sometimes we need to wait a little bit longer for the exception to appear.
+                sleep 3 if example_name == "opal-exception"
+
+                instance_exec(browser, true, nil, &example_specific)
+              rescue Ferrum::JavaScriptError => e
+                instance_exec(browser, true, e, &example_specific)
+              ensure
+                browser.quit if browser
+              end
+            ensure
+              sigterm(pid)
+            end
+          end
+        end
+      end
+
+      it "works in production mode" do
+        Dir.chdir example do
+          Bundler.with_unbundled_env do
+            if ENV.key? 'CI'
+              system("bundle config --local path #{__dir__+"/../vendor/bundle"}")
+            end
+
+            system("bundle install").should be true
+
+            system("bundle exec rake assets:clean").should be true
+            -> { Dir.children(example + "/public/assets") }.should raise_error Errno::ENOENT
+            system("bundle exec rake assets:precompile").should be true
+            Dir.children(example + "/public/assets").length.should be == 3
+
+            ENV['RACK_ENV'] = 'production'
+
+            begin
+              port = free_port
+              pid = spawn("bundle exec rackup -p#{port}")
+              sleep 1
+
+              begin
+                browser = Ferrum::Browser.new(**browser_options)
+                browser.go_to("http://localhost:#{port}/")
+                browser.network.wait_for_idle
+
+                instance_exec(browser, false, nil, &example_specific)
+              rescue Ferrum::JavaScriptError => e
+                instance_exec(browser, false, e, &example_specific)
+              ensure
+                browser.quit if browser
+              end
+            ensure
+              system("bundle exec rake assets:clean").should be true
+              -> { Dir.children(example + "/public/assets") }.should raise_error Errno::ENOENT
+
+              sigterm(pid)
+            end
+          ensure
+            ENV.delete('RACK_ENV')
+          end
+        end
+      end
+    end
+  end
+end

data/spec/plugin_spec.rb

@@ -0,0 +1,237 @@
+require "time"
+require "roda/plugins/sprockets"
+
+RSpec.shared_examples("basic checks") do
+  it "returns a OK result" do
+    req = app.req
+    req.should be_ok
+  end
+
+  it "generates the necessary tags" do
+    req = app.req
+    if debug
+      req.body.should include %'<script src="/assets/#{js_name}.debug.js" type="text/javascript"'
+      req.body.should include %'<link rel="stylesheet" type="text/css" href="/assets/#{css_name}.debug.css">'
+    else
+      req.body.should include %'<script src="/assets/#{js_name}-'
+      req.body.should include %'<link rel="stylesheet" type="text/css" href="/assets/#{css_name}-'
+    end
+  end
+
+  it "generates the necessary files" do
+    req = app.req
+    req_css = app.req(req.css_path)
+    req_js = app.req(req.js_path)
+
+    req_css.should be_ok
+    req_css.body.should include css_value
+
+    req_js.should be_ok
+    req_js.body.should include js_value
+  end
+
+  it "returns a not modified status if the assets haven't been modified" do
+    req = app.req
+
+    etag_css = app.req(req.css_path).headers["ETag"]
+    etag_js = app.req(req.js_path).headers["ETag"]
+
+    req_css = app.req(req.css_path, "HTTP_IF_NONE_MATCH" => etag_css)
+    req_js = app.req(req.js_path, "HTTP_IF_NONE_MATCH" => etag_js)
+
+    req_css.should be_not_modified
+    req_js.should be_not_modified
+  end
+
+  it "appropriately includes source maps or not" do
+    req = app.req
+    req_css = app.req(req.css_path)
+    req_js = app.req(req.js_path)
+
+    if debug
+      req_css.body.should include "/*# sourceMappingURL="
+      req_js.body.should include "//# sourceMappingURL="
+    else
+      req_css.body.should_not include "/*# sourceMappingURL="
+      req_js.body.should_not include "//# sourceMappingURL="
+    end
+  end
+end
+
+RSpec.describe Roda::RodaPlugins::Sprockets do
+  context "simple app" do
+    let(:css_name) { "simple_css" }
+    let(:js_name) { "simple_js" }
+    let(:css_value) { "Simple CSS" }
+    let(:js_value) { "Simple JS" }
+
+    context "in debug mode" do
+      simple_debug_app = Server.gen("simple_css", "simple_js", debug: true)
+
+      let(:app) { simple_debug_app }
+      let(:debug) { true }
+
+      include_examples "basic checks"
+    end
+
+    context "in production mode" do
+      simple_prod_app = Server.gen("simple_css", "simple_js", debug: false)
+
+      let(:app) { simple_prod_app }
+      let(:debug) { false }
+
+      include_examples "basic checks"
+    end
+  end
+
+  context "opal + scss app" do
+    let(:css_name) { "scss_css" }
+    let(:js_name) { "opal_js" }
+    let(:css_value) { "This is SCSS" }
+    let(:js_value) { "$$($nesting, 'Test').$new();" }
+
+    context "in debug mode" do
+      opalscss_debug_app = Server.gen("scss_css", "opal_js", opal: true, debug: true)
+
+      let(:app) { opalscss_debug_app }
+      let(:debug) { true }
+
+      include_examples "basic checks"
+    end
+
+    context "in production mode" do
+      opalscss_prod_app = Server.gen("scss_css", "opal_js", opal: true, debug: false)
+
+      let(:app) { opalscss_prod_app }
+      let(:debug) { false }
+
+      include_examples "basic checks"
+    end
+  end
+
+  context "opal with requires + scss with imports app" do
+    let(:css_name) { "scss_css_with_imports" }
+    let(:js_name) { "opal_js_with_requires" }
+    let(:css_value) { "This is SCSS" }
+    let(:js_value) { "$$($nesting, 'Test').$new();" }
+
+    context "in debug mode" do
+      opalscssreq_debug_app = Server.gen("scss_css_with_imports", "opal_js_with_requires", opal: true, debug: true)
+
+      let(:app) { opalscssreq_debug_app }
+      let(:debug) { true }
+
+      include_examples "basic checks"
+    end
+
+    context "in production mode" do
+      opalscssreq_prod_app = Server.gen("scss_css_with_imports", "opal_js_with_requires", opal: true, debug: false)
+
+      let(:app) { opalscssreq_prod_app }
+      let(:debug) { false }
+
+      include_examples "basic checks"
+    end
+  end
+
+  context "opal with erb + scss with erb app" do
+    let(:css_name) { "scss_css_with_erb" }
+    let(:js_name) { "opal_js_with_erb" }
+    let(:css_value) { "This is ERBSCSS" }
+    let(:js_value) { "$$($nesting, 'TestERB').$new();" }
+
+    context "in debug mode" do
+      opalscsserb_debug_app = Server.gen("scss_css_with_erb", "opal_js_with_erb", opal: true, debug: true)
+
+      let(:app) { opalscsserb_debug_app }
+      let(:debug) { true }
+
+      include_examples "basic checks"
+    end
+
+    context "in production mode" do
+      opalscsserb_prod_app = Server.gen("scss_css_with_erb", "opal_js_with_erb", opal: true, debug: false)
+
+      let(:app) { opalscsserb_prod_app }
+      let(:debug) { false }
+
+      include_examples "basic checks"
+    end
+  end
+
+  context "opal + scss app with compressor" do
+    let(:css_name) { "scss_css" }
+    let(:js_name) { "opal_js" }
+    let(:css_value) { "This is SCSS" }
+    let(:js_value) { "Test" }
+
+    context "in debug mode" do
+      opalscsscomp_debug_app = Server.gen("scss_css", "opal_js",
+        css_compressor: :sassc, js_compressor: :uglify,
+        opal: true, debug: true
+      )
+
+      let(:app) { opalscsscomp_debug_app }
+      let(:debug) { true }
+
+      include_examples "basic checks"
+
+      it "should run uglifier" do
+        req = app.req
+        req_js = app.req(req.js_path)
+
+        req_js.body.should include "$$($nesting, 'Test').$new();"
+      end
+    end
+
+    context "in production mode" do
+      opalscsscomp_prod_app = Server.gen("scss_css", "opal_js",
+        css_compressor: :sassc, js_compressor: :uglify,
+        opal: true, debug: false
+      )
+
+      let(:app) { opalscsscomp_prod_app }
+      let(:debug) { false }
+
+      include_examples "basic checks"
+
+      it "should not run uglifier" do
+        req = app.req
+        req_js = app.req(req.js_path)
+
+        req_js.body.should_not include "$$($nesting, 'Test').$new();"
+      end
+    end
+  end
+
+  context "opal + scss app with cache" do
+    let(:css_name) { "scss_css" }
+    let(:js_name) { "opal_js" }
+    let(:css_value) { "This is SCSS" }
+    let(:js_value) { "$$($nesting, 'Test').$new();" }
+
+    context "in debug mode" do
+      opalscsscache_debug_app = Server.gen("scss_css", "opal_js",
+        opal: true, debug: true,
+        cache: Sprockets::Cache::MemoryStore.new(65536)
+      )
+
+      let(:app) { opalscsscache_debug_app }
+      let(:debug) { true }
+
+      include_examples "basic checks"
+    end
+
+    context "in production mode" do
+      opalscsscache_prod_app = Server.gen("scss_css", "opal_js",
+        opal: true, debug: false,
+        cache: Sprockets::Cache::MemoryStore.new(65536)
+      )
+
+      let(:app) { opalscsscache_prod_app }
+      let(:debug) { false }
+
+      include_examples "basic checks"
+    end
+  end
+end

data/spec/server_helper.rb

@@ -0,0 +1,68 @@
+require "roda"
+
+class Server < Roda
+  class << self
+    def gen(css=nil, js=nil, **kwargs, &block)
+      Class.new Server do |c|
+        unless kwargs.empty?
+          c.plugin :sprockets, root: __dir__, **kwargs
+        end
+
+        if css || js
+          c.route do |r|
+            r.sprockets
+
+            r.root do
+              out = ""
+              out += stylesheet_tag(css) if css
+              out += javascript_tag(js) if js
+              out
+            end
+          end
+        end
+
+        yield(c) if block_given?
+      end
+    end
+
+    # Slightly adapted from https://github.com/jeremyevans/roda/blob/master/spec/spec_helper.rb
+    def req(path = '/', env = {})
+      env['PATH_INFO'] = path.dup
+      env = {"REQUEST_METHOD" => "GET", "PATH_INFO" => "/", "SCRIPT_NAME" => ""}.merge(env)
+      Response.new(*self.call(env))
+    end
+  end
+
+  class Response
+    def initialize(status, headers, body)
+      @status, @headers, @body = status, headers, body
+    end
+
+    def ok?
+      status == 200
+    end
+
+    attr_reader :status, :headers
+
+    def body
+      @body&.join
+    end
+
+    def js_path
+      body =~ /<script src="(.*?)"/
+      $1
+    end
+
+    def css_path
+      body =~ /<link rel="stylesheet" type="text\/css" href="(.*?)"/
+      $1
+    end
+
+    def not_modified?
+      status == 304 &&
+        (body.nil? || body.empty?) &&
+        !headers.key?("Content-Length") &&
+        !headers.key?("Content-Type")
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,59 @@
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+    expectations.syntax = :should
+  end
+
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+  # This option will default to `:apply_to_host_groups` in RSpec 4 (and will
+  # have no way to turn it off -- the option exists only for backwards
+  # compatibility in RSpec 3). It causes shared context metadata to be
+  # 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
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # 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
+
+require "bundler/setup"
+
+require_relative "server_helper"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: roda-sprockets
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 2.0.0rc1
 platform: ruby
 authors:
 - cj
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-08-13 00:00:00.000000000 Z
+date: 2021-08-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: roda
@@ -88,15 +88,47 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/rake.yml"
 - ".gitignore"
+- ".rspec"
+- CHANGELOG.md
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
+- examples/opal-doc/Gemfile
+- examples/opal-doc/README.md
+- examples/opal-doc/Rakefile
+- examples/opal-doc/app.rb
+- examples/opal-doc/app/application.rb
+- examples/opal-doc/config.ru
+- examples/opal-exception/Gemfile
+- examples/opal-exception/README.md
+- examples/opal-exception/Rakefile
+- examples/opal-exception/app.rb
+- examples/opal-exception/app/application.rb
+- examples/opal-exception/config.ru
+- examples/sass/Gemfile
+- examples/sass/Rakefile
+- examples/sass/app.rb
+- examples/sass/assets/css/application.scss
+- examples/sass/config.ru
 - lib/roda/plugins/sprockets.rb
 - lib/roda/plugins/sprockets_task.rb
 - lib/roda/sprockets.rb
 - roda-sprockets.gemspec
+- spec/assets/css/scss_css.scss
+- spec/assets/css/scss_css_with_erb.scss.erb
+- spec/assets/css/scss_css_with_imports.scss
+- spec/assets/css/simple_css.css
+- spec/assets/js/opal_js.rb
+- spec/assets/js/opal_js_with_erb.rb.erb
+- spec/assets/js/opal_js_with_requires.rb
+- spec/assets/js/simple_js.js
+- spec/examples_spec.rb
+- spec/plugin_spec.rb
+- spec/server_helper.rb
+- spec/spec_helper.rb
 homepage: https://github.com/hmdne/roda-sprockets
 licenses:
 - MIT
@@ -112,12 +144,24 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubygems_version: 3.2.22
 signing_key:
 specification_version: 4
 summary: Use sprockets to serve assets in roda.
-test_files: []
+test_files:
+- spec/assets/css/scss_css.scss
+- spec/assets/css/scss_css_with_erb.scss.erb
+- spec/assets/css/scss_css_with_imports.scss
+- spec/assets/css/simple_css.css
+- spec/assets/js/opal_js.rb
+- spec/assets/js/opal_js_with_erb.rb.erb
+- spec/assets/js/opal_js_with_requires.rb
+- spec/assets/js/simple_js.js
+- spec/examples_spec.rb
+- spec/plugin_spec.rb
+- spec/server_helper.rb
+- spec/spec_helper.rb