opal-webpack-loader 0.7.1 → 0.7.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dc53c7f27e7ce42ae61873bdad8307296444236a7838ee00ee74625a0d1e8ef5
-  data.tar.gz: 4c68b4c35cc10d08c6ffa732ef9aad867e5b38ffee3dbbc112065090d56a2957
+  metadata.gz: 35c2949cd7cbe92ee220b608ee25589900f80a9dca13ae0d9a01e0b12f342188
+  data.tar.gz: edcb7595436d4334d3e0dd17c9c6dd5f998a4f70a22335f5fd155faff9575db2
 SHA512:
-  metadata.gz: efd6e89269ecbe339b4678f7fcd671090fc61998cf01dce45de59231cb2715941bfbd792db6a00ec7fcedd9074b800fdd67a09b6a8b14aabed6fd4a6f040ea96
-  data.tar.gz: c2cf4046a017bd28280fe945ca7595865c5fa4349048b2eeb4e18e771e4d1706d265fa6bbfc1fe502d4063b8dd41a848426dcc4c358333c969f8262a41e00bb0
+  metadata.gz: f181858e65471a1915c330d425636ba965f3690271b597ebebd52b39df13a0f3ed905c0038f890147a2556f851a0073271adfed457c39e81bd9c13f7a6055d99
+  data.tar.gz: 9201d624ffc9cb34ad31de04494e82acaf6bfcbd552df24bd202756a44842fab75b3ca91433986fa90ef8999e29fb2b45f006b4147482278344dcd1825481c47

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018, 2019 Jan Biedermann
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/lib/opal-webpack-loader/version.rb

@@ -1,3 +1,3 @@
 module OpalWebpackLoader
-  VERSION="0.7.1"
+  VERSION="0.7.2"
 end

data/readme.md

@@ -0,0 +1,340 @@
+# opal-webpack-loader
+Bundle assets with webpack, resolve and compile opal ruby files and import them in the bundle, without sprockets or the webpacker gem
+ (but can be used with both of them too).
+Includes a loader and resolver plugin for webpack.
+
+### Community and Support
+At the [Isomorfeus Framework Project](http://isomorfeus.com) 
+
+### Features
+- comes with a installer for rails and other frameworks
+- webpack based build process
+- very fast, asynchronous and parallel builds of opal code:
+opal-webpack-loader-0.7.1 compiles all of opal, a bunch of gems and over 19000SLC on a
+Intel® Core™ i7-7700HQ CPU @ 2.80GHz × 8, with 8 workers in around 1850ms
+- opal modules are packaged as es6 modules
+- other webpack features become available, like:
+  - source maps
+  - multiple targets: web (for browsers), node (for server side rendering) and webworker (for Web Workers)
+  - hot module reloading for opal ruby code and stylesheets and html views
+  - tree shaking
+  - code splitting
+  - lazy loading
+  - everything else webpack can do, like loading stylesheets, etc.
+
+### Requirements
+- webpack 4.30
+- webpack-dev-server 3.3.0
+- es6_import_export branch of opal, [PR#1832](https://github.com/opal/opal/pull/1832)
+- if you have webpacker gem installed somewhere, it should be a version supporting webpack 4
+- ruby, version 2.5 or higher recommended
+- bundler, latest version recommended
+
+### Installation
+
+#### Using the installer
+First install the gem:
+```
+gem install 'opal-webpack-loader'
+```
+##### Install for Rails like projects
+If you start a new rails project, the following options are recommended for `rails new`: `--skip-sprockets --skip-javascript`
+
+Then within the projects root directory execute:
+```bash
+owl-install rails
+```
+If you have the webpacker gem installed, you need to merge the configuration in the config/webpacker directory.
+A example for config/webpack/development.js is in the
+[templates](https://github.com/isomorfeus/opal-webpack-loader/blob/master/lib/opal-webpack-loader/templates/webpacker_development.js_example).
+
+Please see the messages of owl-install. You may need to manually add the following gems to the projects Gemfile:
+```ruby
+gem 'opal', github: 'janbiedermann/opal', branch: 'es6_import_export'
+gem 'opal-webpack-loader', '~> 0.6.2' # use the most recent released version here
+```
+
+Then:
+```bash
+yarn install
+bundle install
+```
+Opal ruby files should then go in the newly created `app/opal` directory. With the option -o the directory can be named differently, for example:
+```bash
+owl-install rails -o hyperhyper
+```
+A directory `app/hyperhyper` will be created, opal files should then go there and will be properly resolved by webpack.
+
+Complete set of directories and files created by the installer for projects with a rails like structure:
+```
+project_root
+    +- app
+        +- assets
+            +- javascripts  # javascript entries directory
+            +- styles       # directory for stylesheets
+        +- opal             # directory for opal application files, can be changed with -o
+    +- config
+        +- webpack          # directory for webpack configuration files
+        +- initializers
+            +- opal_webpack_loader.rb  # initializer for owl
+    +- package.json         # package config for npm/yarn and their scripts
+    +- public
+        +- assets           # directory for compiled output files
+    +- Procfile             # config file for foreman
+```
+              
+##### Install for Cuba, Roda, Sinatra and others with a flat structure
+```bash
+owl-install flat
+```
+
+Please see the message of owl-install. You may need to manually add the following gems to the projects Gemfile:
+```ruby
+gem 'opal', github: 'janbiedermann/opal', branch: 'es6_import_export'
+gem 'opal-webpack-loader', '~> 0.5.1'
+```
+
+Then:
+```bash
+yarn install
+bundle install
+```
+The installer produces a `app_loader.rb` which `require './owl_init'`. `app_loader.rb` is used by the compile server to correctly determine opal load
+paths. It should be required by `config.ru`.
+Opal ruby files should then go in the newly created `opal` directory. With the option -o the directory can be named differently, for example:
+```bash
+owl-install rails -o supersuper
+```
+A directory `supersuper` will be created, opal files should then go there and will be properly resolved by webpack.
+
+Complete set of directories and files created by the installer for projects with a flat structure:
+```
+project_root
+    +- owl_init.rb      # initializer for owl
+    +- javascripts      # javascript entries directory
+    +- opal             # directory for opal application files, can be changed with -o
+    +- package.json     # package config for npm/yarn and their scripts
+    +- public
+        +- assets       # directory for compiled output files
+    +- styles           # directory for stylesheets
+    +- webpack          # directory for webpack configuration files
+    +- Procfile         # config file for foreman
+```
+
+#### Manual Installation
+##### Install the accompanying NPM package:
+one of:
+```bash
+npm i opal-webpack-loader
+yarn add opal-webpack-loader
+```
+##### Install the gems
+```bash
+gem install opal-webpack-loader
+```
+or add it to the Gemfile as below and `bundle install`
+```ruby
+source 'https://rubygems.org'
+
+gem 'opal', github: 'janbiedermann/opal', branch: 'es6_import_export' # requires this branch
+gem 'opal-autoloader' # recommended
+gem 'opal-webpack-loader'
+```
+##### Install the configuration
+See the [configuration templates](https://github.com/isomorfeus/opal-webpack-loader/tree/master/lib/opal-webpack-loader/templates)
+and adjust to your preference.
+
+### General Usage
+
+After installing owl with the installer, three scripts are provided in package.json:
+- `development` - runs the webpack-dev-server, use for general development, provides fast reloads, entry is application.js
+- `debug` - runs the webpack-dev-server, use for debugging, provides source maps, entry is application_debug.js. Additional debugging tools may be added there.
+- `production_build` - runs webpack to build assets for production, entry is application.js
+
+These scripts can for example be run with:
+`yarn run debug` or `npm run debug`
+
+The default config provides several targets and entries:
+
+- **Browser**: the webpack target is 'web' and the javascript entry file for imports is `application.js` - general use for the application with all
+browser features, the opal ruby entry file is `opal_loader.rb` in the opal or app/opal directory of the app.
+- **Server Side Rendering**: the webpack target is `node` and the javascript entry file for imports is `application_ssr.js` - general use for the
+application server side rendering, several Browser features are unavailable, no `window`, no `document`, some node features are available,
+like `Buffer`, the opal ruby entry file is `opal_loader.rb` in the opal or app/opal directory of the app.
+(meant to be used with isomorfeus-speednode, standard ExecJS limitations prevent certain webpack features)
+- **Web Worker**: the webpack target is 'webworker' and the javascript entry file for imports is `application_webworker.js` - used to initialize Web
+Workers in the browser, the opal ruby entry file is `opal_webworker_loader.rb` in the opal or app/opal directory of the app.
+
+Only the browser target is build by default. To builds the other target, just add the needed targets to the last line of the webpack config,
+for example to `development.js`:
+default config:
+```javascript
+module.exports = [ browser ];
+```
+modified config with ssr and web_worker targets enabled:
+```javascript
+module.exports = [ browser, ssr, web_worker ];
+```
+Same works for the `debug.js` and `production.js` webpack config files.
+
+Also a Procfile has been installed, for rails its easy to startup rails and webpack with foreman:
+`foreman start` (`gem install foreman` if you dont have it already). It will start rails and webpack-dev-server with the development script.
+
+For non rails installation check the Procfile and add a starter for your app.
+
+#### Opal Ruby Application Files
+For rails installations with the installer they all go into: `app/opal`, for flat installations in the `opal` directory.
+In this directory there already is a `opal_loader.rb` which is the entry point for your app.
+
+#### Stylesheets
+Stylesheets are hot reloaded too with the default config installed by the installer. Also they are imported into application.js by default.
+For rails like applications stylesheets are in `app/assets/stylesheets/application.css`, for flat applications they are in `styles/application.css`.
+SCSS is supported too by the default config.
+
+#### Views
+For rails like applications a watcher for `app/views` is installed by default. The watcher will trigger a page reload when views are changed.
+For flat applications nothing is configured by default, as there are to many ways to generate views, they are not even needed with
+frameworks like isomorfeus. Instead the section for configuring a view watcher is included in the development.js and debug.js webpack
+config, but it is commented out. Please see those files and adjust to your liking.
+
+#### Parallel compilation for speed
+For speed the number of workers for compiling opal ruby files can be adjusted in `package.json` -> "scripts" key:
+Default entries look like:
+`"production_build": "bundle exec opal-webpack-compile-server start 4 webpack --config=config/webpack/production.js"`
+The compile server will start 4 workers for compiling opal files. The recommended number of workers should be 4 for machines with 4 or less cores,
+or equal to the number of cores, for machines with up to 12 cores. More than 12 can't be kept busy by webpack it seems, ymmv.
+Example for 8 cores:
+`"production_build": "bundle exec opal-webpack-compile-server start 8 webpack --config=config/webpack/production.js"`
+### Source Maps
+
+#### Source Map Demo
+[![SourceMap Demo](https://img.youtube.com/vi/SCmDYu_MLQU/0.jpg)](https://www.youtube.com/watch?v=SCmDYu_MLQU)
+
+It shows a exception during a page load. In the console tab of the browsers developer tools, the error message is then expanded and just by clicking
+on the shown file:line_numer link, the browser shows the ruby source code, where the exception occured.
+
+#### Source Map Configuration
+
+The opal-webpack-loader for webpack supports the following options to enable HMR:
+(These are options for the webpack config, not to be confused with the owl ruby project options further down below)
+```javascript
+    loader: 'opal-webpack-loader',
+    options: {
+        sourceMap: true
+    }
+```
+
+- `sourceMap` : enable (`true`) or disable (`false`) source maps. Optional, default: `false`
+
+Also source maps must be enabled in webpack. See [webpack devtool configuration](https://webpack.js.org/configuration/devtool).
+### Hot Module Reloading
+
+#### HMR Demo
+
+[![HMR Demo](https://img.youtube.com/vi/igF3cUsZrAQ/0.jpg)](https://www.youtube.com/watch?v=igF3cUsZrAQ)
+
+(Recommended to watch in FullHD)
+
+#### HMR and Ruby
+
+When a module uses method aliasing and is reloaded, the aliases are applied again, which may lead to a endless recursion of method calls of
+the aliased method once called after hot reloading.
+To prevent that, the alias should be conditional, only be applied if the alias has not been applied before. Or alternatively the original
+method must be restored before aliasing it again.
+Because gems are not hot reloaded, this is not a issue for imported gems, but must be taken care of within the projects code.
+
+Also it must be considered, that other code, which without hot reloading would only execute once during the programs life cycle, possibly will
+execute many times when hot reloaded. "initialization code" should be guarded to prevent it from executing many times.
+
+#### HMR Configuration
+
+The opal-webpack-loader for webpack supports the following options to enable HMR:
+(These are options for the webpack config, not to be confused with the owl ruby project options further down below)
+```javascript
+    loader: 'opal-webpack-loader',
+    options: {
+        hmr: true,
+        hmrHook: 'global.Opal.ViewJS["$force_update!"]();'
+    }
+```
+
+- `hmr` : enable (`true`) or disable (`false`) hot module reloading. Optional, default: `false`
+- `hmrHook` : A javascript expression as string which will be executed after the new code has been loaded.
+Useful to trigger a render or update for React or ViewJS projects.
+
+Note: HMR works only for files within the project tree. Files outside the project tree are not hot reloaded.
+
+### Opal Load Path
+The projects directory for opal ruby files must be in the opal load path. This is done in the initializer for rails apps in
+config/initializers/opal_webpack_loader.rb or in 'owl_init.rb' for non rails apps, for example:
+```ruby
+Opal.append_path(File.realdirpath('app/opal'))
+```
+
+### View Helper
+In Rails or frameworks that support `javscript_include_tag`, add to the app/helpers/application_helper.rb
+```ruby
+module ApplicationHelper
+  include OpalWebpackLoader::RailsViewHelper
+```
+in other frameworks that dont have a `javascript_include_tag`:
+```ruby
+module MyProjectsViewThings
+  include OpalWebpackLoader::ViewHelper
+```
+
+Then you can use in your views:
+```ruby
+owl_script_tag('application.js')
+```
+#### Compile Server and app_loader.rb
+For non rails projects, determining Opal load paths, for the resolver and compile server to work properly, may not be obvious. For these cases
+a file `app_loader.rb` in the projects root can be created which just loads all requirements without starting anything.
+Usually it would just setup bundler with the appropriate options, for example:
+```ruby
+require 'bundler/setup'
+if ENV['MY_PROJECT_ENV'] && ENV['MY_PROJECT_ENV'] == 'test'
+  Bundler.require(:default, :test)
+elsif ENV['MY_PROJECT_ENV'] && ENV['MY_PROJECT_ENV'] == 'production'
+  Bundler.require(:default, :production)
+else
+  Bundler.require(:default, :development)
+end
+require './owl_init.rb' # this is a good place to require the opal-webpack-loader initializer, to get the apps opal load path
+```
+When this file exists, the compile server will load it and generate Opal load paths accordingly for the resolver.
+
+#### Project configuration options for the view helper
+These setting are in the initializer in config/initializers/opal_webpack_loader.rb for rails like apps, or owl_init.rb for others.
+```ruby
+OpalWebpackLoader.use_manifest = false
+```
+If the manifest file should be used, use_manifest should be true.
+```ruby
+OpalWebpackLoader.manifest_path = File.join(Dir.getwd, 'public', 'assets', 'manifest.json')
+```
+Sets the path to the webpack (with the [webpack-manifest-plugin](https://www.npmjs.com/package/webpack-manifest-plugin)) generated manifest.json to look up assets.
+```ruby
+OpalWebpackLoader.client_asset_path = 'http://localhost:3035/assets/'
+```
+The path to prepend to the assets as configured in the webpack config 'publicPath'. 
+In the config example below its `publicPath: 'http://localhost:3025/assets'` so
+client_asset_path should be set to the same.
+
+For **production** use with readily precompiled and compressed assets which contain a fingerprint in the name (webpacks [chunkhash]),
+and if the path in the manifest is the full path to the asset as configured in webpack,
+these settings would work:
+```ruby
+OpalWebpackLoader.use_manifest = true
+OpalWebpackLoader.manifest_path = File.join(Dir.getwd, 'public', 'assets', 'manifest.json')
+OpalWebpackLoader.client_asset_path = ''
+```
+
+For **development** use with webpack-dev-server, with no manifest, these settings would work:
+```ruby
+OpalWebpackLoader.use_manifest = false
+OpalWebpackLoader.manifest_path = File.join(Dir.getwd, 'public', 'assets', 'manifest.json') # doesn't matter, not used
+OpalWebpackLoader.client_asset_path = 'http://localhost:3035/assets/'
+```
+### Example webpack configuration
+See the [configuration templates](https://github.com/isomorfeus/opal-webpack-loader/tree/master/lib/opal-webpack-loader/templates).

metadata

@@ -1,27 +1,27 @@
 --- !ruby/object:Gem::Specification
 name: opal-webpack-loader
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.7.2
 platform: ruby
 authors:
 - Jan Biedermann
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-04-30 00:00:00.000000000 Z
+date: 2019-05-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: opal
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: 0.11.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: 0.11.0
 - !ruby/object:Gem::Dependency
@@ -132,6 +132,7 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- LICENSE
 - bin/opal-webpack-compile-server
 - bin/owl-install
 - lib/opal-webpack-loader.rb
@@ -159,11 +160,7 @@ files:
 - lib/opal-webpack-loader/templates/webpacker_development.js_example
 - lib/opal-webpack-loader/version.rb
 - lib/opal-webpack-loader/view_helper.rb
-- spec/fixtures/flattering/Gemfile
-- spec/fixtures/flattering/config.ru
-- spec/installer_spec.rb
-- spec/owl_spec.rb
-- spec/spec_helper.rb
+- readme.md
 homepage: http://isomorfeus.com
 licenses:
 - MIT
@@ -188,9 +185,4 @@ signing_key:
 specification_version: 4
 summary: Bundle assets with webpack, resolve and compile opal ruby files and import
   them in the bundle.
-test_files:
-- spec/fixtures/flattering/Gemfile
-- spec/fixtures/flattering/config.ru
-- spec/installer_spec.rb
-- spec/owl_spec.rb
-- spec/spec_helper.rb
+test_files: []

data/spec/fixtures/flattering/Gemfile

@@ -1,10 +0,0 @@
-source 'https://rubygems.org'
-git_source(:github) { |repo| "https://github.com/#{repo}.git" }
-
-gem 'puma', '~> 3.12.0', require: false
-
-gem 'roda', '~> 3.15.0'
-
-
-
-

data/spec/fixtures/flattering/config.ru

@@ -1,22 +0,0 @@
-require './app_loader.rb'
-
-class App < Roda
-
-
-  route do |r|
-    r.root do
-      <<~HTML
-      <html>
-        <head>
-          <title>Welcome</title>
-        </head>
-        <body>
-          <div>Hello world!</div>
-        </body>
-      </html>
-      HTML
-    end
-  end
-end
-
-run App.app

data/spec/installer_spec.rb

@@ -1,100 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe 'owl installer' do
-  context 'structure: :app' do
-    before do
-      Dir.chdir('spec')
-      Dir.chdir('test_apps')
-      FileUtils.rm_rf('railing') if Dir.exist?('railing')
-    end
-
-    after do
-      Dir.chdir('..') if Dir.pwd.end_with?('railing')
-      FileUtils.rm_rf('railing') if Dir.exist?('railing')
-      Dir.chdir('..')
-      Dir.chdir('..')
-    end
-
-    it 'can install in a rails app without sprockets and webpacker gem' do
-      `bundle exec rails new railing --skip-git --skip-bundle --skip-sprockets --skip-spring --skip-bootsnap`
-      expect(Dir.exist?('railing')).to be true
-      Dir.chdir('railing')
-      arg_val = %w[rails]
-      expect(Dir.exist?(File.join('railing', 'config', 'webpack'))).to be false
-      OpalWebpackLoader::Installer::CLI.start(arg_val)
-      expect(File.exist?(File.join('app', 'assets', 'javascripts', 'application.js'))).to be true
-      expect(File.exist?(File.join('app', 'assets', 'javascripts', 'application.js_owl_new'))).to be true
-      expect(File.exist?(File.join('app', 'assets', 'javascripts', 'application_common.js'))).to be true
-      expect(File.exist?(File.join('app', 'assets', 'javascripts', 'application_debug.js'))).to be true
-      expect(File.exist?(File.join('app', 'assets', 'javascripts', 'application_ssr.js'))).to be true
-      expect(File.exist?(File.join('app', 'assets', 'javascripts', 'application_web_worker.js'))).to be true
-      expect(File.exist?(File.join('app', 'opal', 'opal_loader.rb'))).to be true
-      expect(File.exist?(File.join('app', 'opal', 'opal_web_worker_loader.rb'))).to be true
-      expect(File.exist?(File.join('config', 'initializers', 'opal_webpack_loader.rb'))).to be true
-      expect(File.exist?(File.join('config', 'webpack', 'debug.js'))).to be true
-      expect(File.exist?(File.join('config', 'webpack', 'development.js'))).to be true
-      expect(File.exist?(File.join('config', 'webpack', 'production.js'))).to be true
-      expect(File.exist?('package.json')).to be true
-      expect(File.exist?('Procfile')).to be true
-    end
-
-    it 'can install in a rails app without sprockets and webpacker gem specifying another opal files dir' do
-      `bundle exec rails new railing --skip-git --skip-bundle --skip-sprockets  --skip-spring --skip-bootsnap`
-      expect(Dir.exist?('railing')).to be true
-      Dir.chdir('railing')
-      arg_val = %w[rails -o hyperhyper]
-      expect(Dir.exist?(File.join('railing', 'config', 'webpack'))).to be false
-      OpalWebpackLoader::Installer::CLI.start(arg_val)
-      expect(File.exist?(File.join('app', 'assets', 'javascripts', 'application.js'))).to be true
-      expect(File.exist?(File.join('app', 'assets', 'javascripts', 'application.js_owl_new'))).to be true
-      expect(File.exist?(File.join('app', 'assets', 'javascripts', 'application_common.js'))).to be true
-      expect(File.exist?(File.join('app', 'assets', 'javascripts', 'application_debug.js'))).to be true
-      expect(File.exist?(File.join('app', 'assets', 'javascripts', 'application_ssr.js'))).to be true
-      expect(File.exist?(File.join('app', 'assets', 'javascripts', 'application_web_worker.js'))).to be true
-      expect(File.exist?(File.join('app', 'hyperhyper', 'hyperhyper_loader.rb'))).to be true
-      expect(File.exist?(File.join('app', 'hyperhyper', 'hyperhyper_web_worker_loader.rb'))).to be true
-      expect(File.exist?(File.join('config', 'initializers', 'opal_webpack_loader.rb'))).to be true
-      expect(File.exist?(File.join('config', 'webpack', 'debug.js'))).to be true
-      expect(File.exist?(File.join('config', 'webpack', 'development.js'))).to be true
-      expect(File.exist?(File.join('config', 'webpack', 'production.js'))).to be true
-      expect(File.exist?('package.json')).to be true
-      expect(File.exist?('Procfile')).to be true
-    end
-  end
-
-  context 'structure: :flat' do
-    before do
-      Dir.chdir('spec')
-      Dir.chdir('test_apps')
-      FileUtils.rm_rf('flattering') if Dir.exist?('flattering')
-    end
-
-    after do
-      Dir.chdir('..') if Dir.pwd.end_with?('flattering')
-      FileUtils.rm_rf('flattering') if Dir.exist?('flattering')
-      Dir.chdir('..')
-      Dir.chdir('..')
-    end
-
-    it 'can install in a roda app' do
-      FileUtils.cp_r(File.join('..', 'fixtures', 'flattering'), File.join('.'))
-      expect(Dir.exist?('flattering')).to be true
-      Dir.chdir('flattering')
-      arg_val = %w[flat]
-      OpalWebpackLoader::Installer::CLI.start(arg_val)
-      expect(File.exist?(File.join('styles', 'application.css'))).to be true
-      expect(File.exist?(File.join('javascripts', 'application.js'))).to be true
-      expect(File.exist?(File.join('javascripts', 'application_common.js'))).to be true
-      expect(File.exist?(File.join('javascripts', 'application_debug.js'))).to be true
-      expect(File.exist?(File.join('javascripts', 'application_ssr.js'))).to be true
-      expect(File.exist?(File.join('opal', 'opal_loader.rb'))).to be true
-      expect(File.exist?(File.join('owl_init.rb'))).to be true
-      expect(File.exist?(File.join('app_loader.rb'))).to be true
-      expect(File.exist?(File.join('webpack', 'debug.js'))).to be true
-      expect(File.exist?(File.join('webpack', 'development.js'))).to be true
-      expect(File.exist?(File.join('webpack', 'production.js'))).to be true
-      expect(File.exist?('package.json')).to be true
-      expect(File.exist?('Procfile')).to be true
-    end
-  end
-end

data/spec/owl_spec.rb

@@ -1,105 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe 'owl' do
-  context 'in a rails app' do
-    before :all do
-      `npm pack`
-    end
-
-    before do
-      Dir.chdir('spec')
-      Dir.chdir('test_apps')
-      FileUtils.rm_rf('railing') if Dir.exist?('railing')
-      `yarn cache clean`
-    end
-
-    after do
-      Dir.chdir('..') if Dir.pwd.end_with?('railing')
-      FileUtils.rm_rf('railing') if Dir.exist?('railing')
-      Dir.chdir('..')
-      Dir.chdir('..')
-    end
-
-    it 'can run the production build script' do
-      `bundle exec rails new railing --skip-git --skip-bundle --skip-sprockets --skip-javascript --skip-spring --skip-bootsnap`
-      expect(Dir.exist?('railing')).to be true
-      Dir.chdir('railing')
-      arg_val = %w[rails]
-      expect(Dir.exist?(File.join('railing', 'config', 'webpack'))).to be false
-      OpalWebpackLoader::Installer::CLI.start(arg_val)
-      gemfile = File.read('Gemfile')
-      gemfile << <<~GEMS
-
-      gem 'opal', github: 'janbiedermann/opal', branch: 'es6_import_export'
-      gem 'opal-webpack-loader', path: '#{File.realpath(File.join('..','..', '..', '..', 'opal-webpack-loader'))}'
-
-      GEMS
-      File.write('Gemfile', gemfile)
-      # add local owl npm package
-      package_json = Oj.load(File.read('package.json'), mode: :strict)
-      package_json["devDependencies"].delete("opal-webpack-loader")
-      File.write('package.json', Oj.dump(package_json, mode: :strict))
-      `yarn add file:../../../opal-webpack-loader-#{OpalWebpackLoader::VERSION}.tgz --dev`
-      `yarn install`
-      # bundler set some environment things, but we need a clean environment, so things don't get mixed up, use env
-      `env -i PATH="#{ENV['PATH']}" bundle install`
-      expect(File.exist?('Gemfile.lock')).to be true
-      `env -i PATH="#{ENV['PATH']}" yarn run production_build`
-      expect(File.exist?(File.join('public', 'assets', 'manifest.json'))).to be true
-      manifest = Oj.load(File.read(File.join('public', 'assets', 'manifest.json')), mode: :strict)
-      application_js = manifest['application.js']
-      expect(File.exist?(File.join('public', application_js))).to be true
-    end
-  end
-
-  context 'in a roda app' do
-    before :all do
-      `npm pack`
-    end
-
-    before do
-      Dir.chdir('spec')
-      Dir.chdir('test_apps')
-      FileUtils.rm_rf('flattering') if Dir.exist?('flattering')
-      `yarn cache clean`
-    end
-
-    after do
-      Dir.chdir('..') if Dir.pwd.end_with?('flattering')
-      FileUtils.rm_rf('flattering') if Dir.exist?('flattering')
-      Dir.chdir('..')
-      Dir.chdir('..')
-    end
-
-    it 'can run the production build script in a roda app' do
-      FileUtils.cp_r(File.join('..', 'fixtures', 'flattering'), File.join('.'))
-      expect(Dir.exist?('flattering')).to be true
-      Dir.chdir('flattering')
-      arg_val = %w[flat]
-      OpalWebpackLoader::Installer::CLI.start(arg_val)
-
-      gemfile = File.read('Gemfile')
-      gemfile << <<~GEMS
-
-      gem 'opal', github: 'janbiedermann/opal', branch: 'es6_import_export'
-      gem 'opal-webpack-loader', path: '#{File.realpath(File.join('..','..', '..', '..', 'opal-webpack-loader'))}'
-
-      GEMS
-      File.write('Gemfile', gemfile)
-      # add local owl npm package
-      package_json = Oj.load(File.read('package.json'), mode: :strict)
-      package_json["devDependencies"].delete("opal-webpack-loader")
-      File.write('package.json', Oj.dump(package_json, mode: :strict))
-      `yarn add file:../../../opal-webpack-loader-#{OpalWebpackLoader::VERSION}.tgz --dev`
-      `yarn install`
-      # bundler set some environment things, but we need a clean environment, so things don't get mixed up, use env
-      `env -i PATH="#{ENV['PATH']}" bundle install`
-      expect(File.exist?('Gemfile.lock')).to be true
-      `env -i PATH="#{ENV['PATH']}" yarn run production_build`
-      expect(File.exist?(File.join('public', 'assets', 'manifest.json'))).to be true
-      manifest = Oj.load(File.read(File.join('public', 'assets', 'manifest.json')), mode: :strict)
-      application_js = manifest['application.js']
-      expect(File.exist?(File.join('public', application_js))).to be true
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,17 +0,0 @@
-require 'fileutils'
-require 'oj'
-require 'thor'
-require_relative '../lib/opal-webpack-loader/version'
-require_relative '../lib/opal-webpack-loader/installer_cli'
-
-RSpec.configure do |config|
-  config.expect_with :rspec do |expectations|
-    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
-  end
-
-  config.mock_with :rspec do |mocks|
-    mocks.verify_partial_doubles = true
-  end
-
-  config.shared_context_metadata_behavior = :apply_to_host_groups
-end