roda-sprockets 1.1.0.rc1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a4a70ad21f0db49bb53cea400c3e90c27e2cae1c1d791f5c6dd471ee89b27621
-  data.tar.gz: 4bb46d275d252145e7406463d9a6fd1e6171eacc1bc59ff45d10e977de3b030e
+  metadata.gz: fd58a6b5449b9ba795b8a6d89873786092742e2fc5e747801c7050725a838dfd
+  data.tar.gz: 2fd13d4132906fb1d2bb84b614b3abcb8a25075d16764adcb1368b4fd224c199
 SHA512:
-  metadata.gz: 26eee21ed69f840bc04a1b024bf7d4ce7347a12d917cbfcd3eada64a7b9a76288748e99889a40fe273a150c92702c2a7048c369b1445fc078d888300055458f2
-  data.tar.gz: 839696f0f772909e113c14776eccf09a961723ca2dd2c33aa6edf252b3d3fb3ddd078a5021889ffd292bd3f92d41c0510ec710afbad1af4af2ce9a2034c0a037
+  metadata.gz: 68c501fc657c52cffe278758acd7fb855ffd83a90eb5a3eb1defdf39c111be43857e75be41a18123cb68a42c22058ee4d94f52fd3bd5d6689f75695251b83d18
+  data.tar.gz: 8835e128d39fd716d6de20e9404ff1a0ef01a5b256bc159aa090cd4e1bea8d34f8d77442ea1867fb6c8976de383f2a986e886c7700aeaaa3610bfff02a6e2336

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

@@ -1,3 +1,10 @@
+v2.0.0
+
+- :debug argument now defaults to true, if RACK_ENV is development or test,
+  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)

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/README.md

@@ -22,36 +22,44 @@ And then execute:
 ```ruby
 class App < Roda
    plugin :sprockets, precompile: %w(site.js site.css),
-                      public_path: 'public/assets/',
                       opal: true,
-                      debug: true
    plugin :public
 
    route do |r|
      r.public
-     r.sprockets
-   end     
+     r.sprockets if %w[development test].include? ENV['RACK_ENV']
+   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]`.
+* `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 or test,
+  false otherwise (in rake tasks it's false too)
+* `cache` - a `Sprockets::Cache` instance, default: nil (no cache)
 
 ### Templates:
 
@@ -89,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:
@@ -111,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/app.rb

@@ -3,13 +3,12 @@ require 'roda'
 class App < Roda
    plugin :sprockets, precompile: %w(application.js),
                       prefix: %w(app/),
-                      opal: true,
-                      debug: ENV['RACK_ENV'] != 'production'
+                      opal: true
    plugin :public
 
    route do |r|
      r.public
-     r.sprockets
+     r.sprockets if %w[development test].include? ENV['RACK_ENV']
 
      r.root do
        <<~END

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/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/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 %w[development test].include? ENV['RACK_ENV']
+
+     r.root do
+       <<~END
+         <!doctype html>
+         <html>
+           <head>
+             #{ javascript_tag 'application' }
+             #{ opal_require 'application' }
+           </head>
+         </html>
+       END
+     end
+   end     
+end

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 %w[development test].include? ENV['RACK_ENV']
+
+     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

@@ -18,7 +18,7 @@ class Roda
         host:           nil,
         digest:         true,
         opal:           false,
-        debug:          false,
+        debug:          nil,
         cache:          nil,
       }.freeze
 
@@ -28,13 +28,21 @@ class Roda
         else
           app.opts[:sprockets] = plugin_options.dup
         end
-        options = app.opts[:sprockets].merge! plugin_options
+        options = app.opts[:sprockets]
         DEFAULTS.each { |k, v| options[k] = v unless options.key?(k) }
 
         if !options[:root]
           options[:root] = app.opts[:root] || Dir.pwd
         end
 
+        if options[:debug].nil?
+          if %w[development test].include? ENV['RACK_ENV']
+            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
         require 'opal/sprockets' if options[:opal]
@@ -76,12 +84,12 @@ class Roda
 
         options[:sprockets_helpers].environment = options[:sprockets]
         options[:sprockets_helpers].digest      = options[:digest]
-        options[:sprockets_helpers].prefix      = options[:path_prefix] unless options[:path_prefix].nil?
+        options[:sprockets_helpers].prefix      = options[:path_prefix]
         options[:sprockets_helpers].debug       = options[:debug]
 
         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]
@@ -94,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
@@ -142,7 +154,7 @@ class Roda
               # (See: https://github.com/hmdne/roda-sprockets/issues/1)
               nil
             when Array
-              response.join("\n")
+              response.join
             else
               response.to_s
             end

data/lib/roda/plugins/sprockets_task.rb

@@ -7,6 +7,14 @@ class Roda
     module Sprockets
       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
@@ -18,11 +26,7 @@ class Roda
         end
 
         def sprockets_options
-          @opts ||= begin
-            opts = @app_klass.sprockets_options.dup
-            opts[:debug] = false
-            opts
-          end
+          @app_klass.sprockets_options
         end
 
         def define

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.1.0.rc1'
+  spec.version       = '2.0.0'
   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.1.0.rc1
+  version: 2.0.0
 platform: ruby
 authors:
 - cj
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-08-20 00:00:00.000000000 Z
+date: 2021-09-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: roda
@@ -88,23 +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/Gemfile.lock
 - 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
@@ -120,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: 1.3.1
+      version: '0'
 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

data/examples/opal-doc/Gemfile.lock

@@ -1,47 +0,0 @@
-PATH
-  remote: ../..
-  specs:
-    roda-sprockets (1.0.2)
-      roda (~> 3)
-      sprockets (>= 2.2)
-      sprockets-helpers (>= 1.4.0)
-
-GEM
-  remote: https://rubygems.org/
-  specs:
-    ast (2.4.2)
-    concurrent-ruby (1.1.9)
-    nio4r (2.5.7)
-    opal (1.2.0)
-      ast (>= 2.3.0)
-      parser (~> 3.0)
-    opal-sprockets (1.0.1)
-      opal (>= 1.0, < 2.0)
-      sprockets (~> 4.0)
-      tilt (>= 1.4)
-    parser (3.0.2.0)
-      ast (~> 2.4.1)
-    puma (5.4.0)
-      nio4r (~> 2.0)
-    rack (2.2.3)
-    rake (13.0.6)
-    roda (3.46.0)
-      rack
-    sprockets (4.0.2)
-      concurrent-ruby (~> 1.0)
-      rack (> 1, < 3)
-    sprockets-helpers (1.4.0)
-      sprockets (>= 2.2)
-    tilt (2.0.10)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  opal-sprockets
-  puma
-  rake
-  roda-sprockets!
-
-BUNDLED WITH
-   2.1.4