opal-webpack-loader 0.9.11 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: df7daa4166a459e2bbd8942eb051e176718b2f0f2b3e0a8eec03d4c3c7232607
-  data.tar.gz: e4ca6d4e0a2f3ccb8696d1d6d4cfa6f0812e9342511ca888d26a725a98370701
+  metadata.gz: 75cfc2e9527b252335ad359e1eb5c7aa476cec879ed76c4501b686a50f39b1f2
+  data.tar.gz: b6d13eac5c5eaa0e3c46dfd15b8f59d01d59124f92608c741e93952c87bb04f6
 SHA512:
-  metadata.gz: df26e49ff98da208b57f55e253b6c4c9f5a25ac3dba28b7d9485882f8e207069e24acbaf730368a2da543e2d57030e4c36c230350bfb025aed6c3b50f0ebfcc9
-  data.tar.gz: 2367ec570bc9ca4fcb28b1829c992ab3ee2365e3119b90040696b0bf2da55427ddafb0ff0ec128c645b4c1a7d701a5cc3bb87be03d841006f236a532dd91e1df
+  metadata.gz: c9edddd5f0a21625c5376dbf609e594a35bfe36ab84ca2fb804fa7f011093e8a45aa516530bb0dceceec4dcc069619dc0e7c31ceecfd3f68a5ad0c6caf39699f
+  data.tar.gz: f21627293c524a6db7f7c53f89e83f13f77519597133c05dd992173b7d2cff05f0ab915cfe7eb8e52f036ce448f3905e572d75a2d345cefe93990ece36ad342b

data/README.md

@@ -0,0 +1,215 @@
+<h1 align="center">
+  <img src="https://raw.githubusercontent.com/isomorfeus/opal-webpack-loader/master/docs/owl.png" 
+  align="center" title="Opal logo by Elia Schito combined with Webpack Logo" width="111" height="125" />
+  <br/>
+  opal-webpack-loader<br/>
+  <img src="https://img.shields.io/badge/Opal-Ruby%20💛%20JavaScript%20💛%20Webpack-yellow.svg?logo=ruby&style=social&logoColor=777"/>
+</h1>
+
+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) 
+
+### Tested
+[TravisCI](https://travis-ci.org): [![Build Status](https://travis-ci.org/isomorfeus/opal-webpack-loader.svg?branch=master)](https://travis-ci.org/isomorfeus/opal-webpack-loader)
+
+### 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
+- support for memcached or redis as compiler cache
+- fast builds on windows too, parallel when building multiple assets with parallel webpack
+- opal modules are packaged as es6 modules
+- support for rails with webpacker
+- 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
+- opal-webpack-loader consists of 2 parts, the npm package and the gem, both are required and must be the same version.
+- webpack ^4.46
+- webpack-dev-server ^3.11.0
+- one of the ES6 modules branches of opal
+  - [PR#1973](https://github.com/opal/opal/pull/1973), (experimental) implementing ES6 modules and changes for 'strict' mode,
+    based on Opal master 1.0.0 using javascript string objects "mutable strings" by default for all strings
+    
+    `gem 'opal', github: 'janbiedermann/opal', branch: 'es6_modules_string'`
+    
+  - [PR#1976](https://github.com/opal/opal/pull/1976), (recommended) implementing ES6 modules and changes for 'strict' mode,
+    based on Opal master 1.1.0 using javascript string primitives and providing nice features like `require_lazy 'my_module'`
+    
+    `gem 'opal', github: 'janbiedermann/opal', branch: 'es6_modules_1_1'`
+    
+- if you have the 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'
+```
+
+Continue here:
+- [Install for Rails like projects](https://github.com/isomorfeus/opal-webpack-loader/blob/master/docs/installation_rails.md)
+- [Install for Cuba, Roda, Sinatra and other projects with a flat structure](https://github.com/isomorfeus/opal-webpack-loader/blob/master/docs/installation_flat.md)           
+- [Manual Installation](https://github.com/isomorfeus/opal-webpack-loader/blob/master/docs/installation_manual.md)
+
+### Example applications
+- [Are here](https://github.com/isomorfeus/opal-webpack-loader/tree/master/example_apps/)
+- A minimal webpack only example from @sunrick is [here](https://github.com/sunrick/opal-hello-world-webpack).
+
+### General Usage without Webpacker
+
+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
+
+Since version 0.8.0 the number of CPUs is automatically determined and a appropriate number of of compile server workers is started automatically.
+
+### Source Maps
+
+[Source Maps](https://github.com/isomorfeus/opal-webpack-loader/blob/master/docs/source_maps.md)
+
+### Hot Module Reloading
+[Hot Module Reloading](https://github.com/isomorfeus/opal-webpack-loader/blob/master/docs/hot_module_reloading.md)
+
+### 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['RACK_ENV'] && ENV['RACK_ENV'] == 'test'
+  Bundler.require(:default, :test)
+elsif ENV['RACK_ENV'] && ENV['RACK_ENV'] == 'production'
+  Bundler.require(:default, :production)
+else
+  Bundler.require(:default, :development)
+end
+Opal.append_path(File.realdirpath('opal')) # this is a good place to add the directory with opal files to the 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/'
+```
+### Advanced Options
+[Advanced Options](https://github.com/isomorfeus/opal-webpack-loader/blob/master/docs/advanced_options.md)
+### Tests
+- clone the repo
+- `bundle install`
+- `bundle exec rspec`

data/bin/opal-webpack-compile-server

@@ -1,6 +1,5 @@
 #!/usr/bin/env ruby
 require 'digest'
-require 'open3'
 require 'oj'
 require 'c_lexer'
 require 'optparse'

data/bin/opal-webpack-windows-compile-server

@@ -0,0 +1,125 @@
+#!/usr/bin/env ruby
+require 'digest'
+require 'oj'
+require 'c_lexer'
+require 'optparse'
+require 'opal/paths'
+require 'opal/source_map'
+require 'opal/compiler'
+require 'opal-webpack-loader/load_path_manager'
+require 'opal-webpack-loader/pipe_server'
+
+modules_to_require = []
+compiler_options = {}
+compile_server_options = {}
+cache = false
+
+OptionParser.new do |opts|
+  opts.on('-r', '--require MODULE', 'Require the module before starting the compile server.') do |m|
+    modules_to_require << m
+  end
+
+  opts.on('-I', '--include DIR', 'Append a load path (may be used more than once)') do |i|
+    $:.unshift(File.expand_path(i))
+  end
+
+  opts.on('-d', '--dynamic-require-severity SEVERITY', 'Compiler option, one of: error, warning, ignore.') do |s|
+    if %w[error warning ignore].include?(s)
+      compiler_options[:dynamic_require_severity] = s.to_sym
+    end
+  end
+
+  opts.on('-t', '--true FLAG', 'Set compiler flag to true.' ) do |f|
+    compiler_options[f.to_sym] = true
+  end
+
+  opts.on('-f', '--false FLAG', 'Set compiler flag to false.' ) do |f|
+    compiler_options[f.to_sym] = false
+  end
+
+  opts.on('-l', '--load-paths-cache PATH', 'Path to load path cache json') do |l|
+    compile_server_options[:load_paths_cache] = l
+  end
+
+  opts.on('-p', '--pipe-name PATH', 'Name of the named pipe.') do |p|
+    compile_server_options[:pipe_name] = p
+  end
+
+  opts.on('-m', '--memcached URL', 'URL of memcached server. Will enable use of memcached for caching compiler results.') do |m|
+    compile_server_options[:memcached] = m
+    require 'dalli'
+    cache = Dalli::Client.new(compile_server_options[:memchached])
+  end
+
+  opts.on('-e', '--redis URL', 'URL of redis server. Will enable use of redis for caching compiler results.') do |e|
+    compile_server_options[:redis] = e
+    require 'redis'
+    cache = Redis.new(url: compile_server_options[:redis])
+  end
+end.parse!
+
+compiler_options.merge!(es6_modules: true)
+
+modules_to_require.each do |mod|
+  require mod
+end
+
+def compile(request, cache, compiler_options)
+  begin
+    request_json = Oj.load(request.chop!, mode: :strict)
+
+    compile_source_map = request_json["source_map"]
+    filename = request_json["filename"]
+    source = File.read(filename)
+    if cache
+      source_digest = Digest::SHA1.hexdigest(source)
+      key = "owl_#{compiler_options_digest}_#{source_digest}_#{compile_source_map}"
+      result_json = cache.get(key)
+      return result_json if result_json
+    end
+    c = Opal::Compiler.new(source, compiler_options.merge(file: filename))
+    result = { 'javascript' => c.compile }
+    if compile_source_map
+      result['source_map'] = c.source_map.as_json
+      result['source_map']['file'] = filename
+    end
+    result['required_trees'] = c.required_trees
+    result_json = Oj.dump(result, mode: :strict)
+    cache.set(key, result_json) if cache
+    result_json
+  rescue Exception => e
+    Oj.dump({ 'error' => { 'name' => e.class.to_s, 'message' => e.message, 'backtrace' => e.backtrace.join("\n") } }, mode: :strict)
+  end
+end
+
+if ARGV[0] == 'start'
+  number_of_instances = ARGV[1].to_i
+  number_of_instances == 4 if number_of_instances == 0
+else
+  raise 'arguments must be either "stop" or "start number_of_instances"'
+  exit(1)
+end
+
+load_paths = OpalWebpackLoader::LoadPathManager.read_load_paths_cache(compile_server_options[:load_paths_cache])
+if load_paths
+  Opal.append_paths(*load_paths)
+end
+
+begin
+  OpalWebpackLoader::PipeServer.new(compile_server_options[:pipe_name], number_of_instances) do |request|
+    if request
+      if request.start_with?('command:stop')
+        STDERR.puts "Exiting with drama."
+        exit(0)
+      else
+        result = compile(request, cache, compiler_options)
+        result
+      end
+    end
+  end.run
+rescue Exception => e
+  STDERR.puts "opal-webpack-windows-compile-server couldn't start:"
+  STDERR.puts e.backtrace.join("\n")
+  STDERR.puts e.message
+  exit 1
+end

data/bin/owl-compiler

@@ -0,0 +1,100 @@
+#!/usr/bin/env ruby
+require 'digest'
+require 'oj'
+require 'c_lexer'
+require 'optparse'
+require 'opal/paths'
+require 'opal/source_map'
+require 'opal/compiler'
+require 'opal-webpack-loader/load_path_manager'
+
+modules_to_require = []
+compiler_options = {}
+compile_server_options = {}
+
+OptionParser.new do |opts|
+  opts.on('-r', '--require MODULE', 'Require the module before starting the compile server.') do |m|
+    modules_to_require << m
+  end
+
+  opts.on('-I', '--include DIR', 'Append a load path (may be used more than once)') do |i|
+    $:.unshift(File.expand_path(i))
+  end
+
+  opts.on('-d', '--dynamic-require-severity SEVERITY', 'Compiler option, one of: error, warning, ignore.') do |s|
+    if %w[error warning ignore].include?(s)
+      compiler_options[:dynamic_require_severity] = s.to_sym
+    end
+  end
+
+  opts.on('-t', '--true FLAG', 'Set compiler flag to true.' ) do |f|
+    compiler_options[f.to_sym] = true
+  end
+
+  opts.on('-f', '--false FLAG', 'Set compiler flag to false.' ) do |f|
+    compiler_options[f.to_sym] = false
+  end
+
+  opts.on('-l', '--load-paths-cache PATH', 'Path to load path cache json') do |l|
+    compile_server_options[:load_paths_cache] = l
+  end
+
+  opts.on('-s', '--source-file PATH', 'Path of the file to compile.') do |s|
+    compile_server_options[:source_file] = s
+  end
+
+  opts.on('-c', '--create-map', 'Create source map.') do
+    compiler_server_options[:source_map] = true
+  end
+
+  opts.on('-m', '--memcached URL', 'URL of memcached server. Will enable use of memcached for caching compiler results.') do |m|
+    require 'dalli'
+    compile_server_options[:memcached] = m
+    compile_server_options[:cache] = Dalli::Client.new(compile_server_options[:memchached])
+  end
+
+  opts.on('-e', '--redis URL', 'URL of redis server. Will enable use of redis for caching compiler results.') do |e|
+    require 'redis'
+    compile_server_options[:redis] = e
+    compile_server_options[:cache] = Redis.new(url: other_options[:redis])
+  end
+end.parse!
+
+modules_to_require.each do |mod|
+  require mod
+end
+
+load_paths = OpalWebpackLoader::LoadPathManager.read_load_paths_cache(compile_server_options[:load_paths_cache])
+if load_paths
+  Opal.append_paths(*load_paths)
+end
+
+compile_source_map = compile_server_options[:source_map]
+filename = compile_server_options[:source_file]
+source = File.read(filename)
+compiler_options.merge!(es6_modules: true)
+compiler_options.merge!(file: filename)
+
+begin
+  if compile_server_options[:cache]
+    source_digest = Digest::SHA1.hexdigest(source)
+    key = "owl_#{compiler_options_digest}_#{source_digest}_#{compile_source_map}"
+    result_json = compile_server_options[:cache].get(key)
+    if result_json
+      STDOUT.puts result_json
+      exit 0
+    end
+  end
+  c = Opal::Compiler.new(source, compiler_options)
+  result = { 'javascript' => c.compile }
+  if compile_source_map
+    result['source_map'] = c.source_map.as_json
+    result['source_map']['file'] = filename
+  end
+  result['required_trees'] = c.required_trees
+  result_json = Oj.dump(result, mode: :strict)
+  compile_server_options[:cache].set(key, result_json) if compile_server_options[:cache]
+  STDOUT.puts result_json
+rescue Exception => e
+  STDOUT.puts Oj.dump({ 'error' => { 'name' => e.class.to_s, 'message' => e.message, 'backtrace' => e.backtrace.join("\n") } }, mode: :strict)
+end

data/lib/opal-webpack-loader.rb

@@ -39,10 +39,13 @@ OpalWebpackLoader.client_asset_path = 'http://localhost:3035/assets/'
 OpalWebpackLoader.use_manifest = false
 
 # TODO require yarn instead of npm
-# TODO don't depend on which for non unixes
-npm = `which npm`.chop
+npm = if Gem.win_platform?
+        `where npm`.chop.lines.last
+      else
+        `which npm`.chop
+      end
 
-if npm != ''
+if !npm.nil? && !npm.empty?
   bin_dir = `npm bin`.chop
   begin
     owl_npm_version = `#{File.join(bin_dir, 'opal-webpack-loader-npm-version')}`.chop

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

@@ -0,0 +1,219 @@
+require 'ffi'
+
+module OpalWebpackLoader
+  module WindowsyThings
+    extend FFI::Library
+
+    ffi_lib :kernel32, :user32
+
+    ERROR_IO_PENDING      = 997
+    ERROR_PIPE_CONNECTED  = 535
+    ERROR_SUCCESS         = 0
+    
+    FILE_FLAG_OVERLAPPED  = 0x40000000
+    
+    INFINITE              = 0xFFFFFFFF
+    INVALID_HANDLE_VALUE  = FFI::Pointer.new(-1).address
+
+    PIPE_ACCESS_DUPLEX    = 0x00000003
+    PIPE_READMODE_BYTE    = 0x00000000
+    PIPE_READMODE_MESSAGE = 0x00000002
+    PIPE_TYPE_BYTE        = 0x00000000
+    PIPE_TYPE_MESSAGE     = 0x00000004
+    PIPE_WAIT             = 0x00000000
+
+    QS_ALLINPUT           = 0x04FF
+
+    typedef :uintptr_t, :handle
+
+    attach_function :ConnectNamedPipe, [:handle, :pointer], :ulong
+    attach_function :CreateEvent, :CreateEventA, [:pointer, :ulong, :ulong, :string], :handle
+    attach_function :CreateNamedPipe, :CreateNamedPipeA, [:string, :ulong, :ulong, :ulong, :ulong, :ulong, :ulong, :pointer], :handle
+    attach_function :DisconnectNamedPipe, [:handle], :bool
+    attach_function :FlushFileBuffers, [:handle], :bool
+    attach_function :GetLastError, [], :ulong
+    attach_function :GetOverlappedResult, [:handle, :pointer, :pointer, :bool], :bool
+    attach_function :MsgWaitForMultipleObjects, [:ulong, :pointer, :ulong, :ulong, :ulong], :ulong
+    attach_function :ReadFile, [:handle, :buffer_out, :ulong, :pointer, :pointer], :bool
+    attach_function :SetEvent, [:handle], :bool
+    attach_function :WaitForMultipleObjects, [:ulong, :pointer, :ulong, :ulong], :ulong
+    attach_function :WriteFile, [:handle, :buffer_in, :ulong, :pointer, :pointer], :bool
+  end
+
+  class PipeServer
+    include OpalWebpackLoader::WindowsyThings
+
+    CONNECTING_STATE = 0
+    READING_STATE    = 1
+    WRITING_STATE    = 2
+    INSTANCES        = 4
+    PIPE_TIMEOUT     = 5000
+    BUFFER_SIZE      = 65536
+
+    class Overlapped < FFI::Struct
+      layout(
+        :Internal, :uintptr_t,
+        :InternalHigh, :uintptr_t,
+        :Offset, :ulong,
+        :OffsetHigh, :ulong,
+        :hEvent, :uintptr_t
+      )
+    end
+
+    def initialize(pipe_name, instances = 4, &block)
+      @run_block = block
+      @full_pipe_name = "\\\\.\\pipe\\#{pipe_name}"
+      @instances = instances
+      @events = []
+      @events_pointer = FFI::MemoryPointer.new(:uintptr_t, @instances)
+      @pipes = []
+    end
+
+    def run
+      create_instances
+      while_loop
+    end
+
+    private
+
+    def create_instances
+      (0...@instances).each do |i|
+        @events[i] = CreateEvent(nil, 1, 1, nil)
+        raise "CreateEvent failed with #{GetLastError()}" unless @events[i]
+
+        overlap = Overlapped.new
+        overlap[:hEvent] = @events[i]
+
+        @pipes[i] = { overlap: overlap, instance: nil, request: FFI::Buffer.new(1, BUFFER_SIZE), bytes_read: 0, reply: FFI::Buffer.new(1, BUFFER_SIZE), bytes_to_write: 0, state: nil, pending_io: false }
+        @pipes[i][:instance] = CreateNamedPipe(@full_pipe_name, 
+                                              PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED,
+                                              PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE | PIPE_WAIT,
+                                              @instances,
+                                              BUFFER_SIZE,
+                                              BUFFER_SIZE,
+                                              PIPE_TIMEOUT,
+                                              nil)
+
+        raise "CreateNamedPipe failed with #{GetLastError()}" if @pipes[i][:instance] == INVALID_HANDLE_VALUE
+        @pipes[i][:pending_io] = connect_to_new_client(i)
+        @pipes[i][:state] = @pipes[i][:pending_io] ? CONNECTING_STATE : READING_STATE
+      end
+      @events_pointer.write_array_of_ulong_long(@events)
+      nil
+    end
+
+    def while_loop
+      while true
+        i = MsgWaitForMultipleObjects(@instances, @events_pointer, 0, INFINITE, QS_ALLINPUT)
+        # Having this STDOUT.putc is essential, otherwise there is a tendency to block within MsgWaitForMultipleObjects ...
+        STDOUT.putc "."
+        # ... because the ruby interpreter is waiting for objects too on Windows. Thats why we wait for QS_ALLINPUT and
+        # with STDOUT.putc give back control to the ruby interpreter that it can handle its things.
+        if i < 0 || i > (@instances - 1)
+          STDERR.puts "Pipe index out of range. Maybe a error occured."
+          next
+        end
+
+        if @pipes[i][:pending_io]
+          bytes_transferred = FFI::MemoryPointer.new(:ulong)
+          success = GetOverlappedResult(@pipes[i][:instance], @pipes[i][:overlap], bytes_transferred, false)
+
+          case @pipes[i][:state]
+          when CONNECTING_STATE
+            raise "Error #{GetLastError()}" unless success
+            @pipes[i][:state] = READING_STATE
+          when READING_STATE
+            if !success || bytes_transferred.read_ulong == 0
+              disconnect_and_reconnect(i)
+              next
+            else
+              @pipes[i][:bytes_read] = bytes_transferred.read_ulong
+              @pipes[i][:state] = WRITING_STATE
+            end
+          when WRITING_STATE
+            if !success || bytes_transferred.read_ulong != @pipes[i][:bytes_to_write]
+              disconnect_and_reconnect(i)
+              next
+            else
+              @pipes[i][:state] = READING_STATE
+            end
+          else
+            raise "Invalid pipe state."
+          end
+        end
+
+        case @pipes[i][:state]
+        when READING_STATE
+          bytes_read = FFI::MemoryPointer.new(:ulong)
+          success = ReadFile(@pipes[i][:instance], @pipes[i][:request], BUFFER_SIZE, bytes_read, @pipes[i][:overlap].to_ptr)
+          if success && bytes_read.read_ulong != 0
+            @pipes[i][:pending_io] = false
+            @pipes[i][:state] = WRITING_STATE
+            next
+          end
+
+          err = GetLastError()
+          if !success && err == ERROR_IO_PENDING
+            @pipes[i][:pending_io] = true
+            next
+          end
+
+          disconnect_and_reconnect(i)
+        when WRITING_STATE
+          @pipes[i][:reply] = @run_block.call(@pipes[i][:request].get_string(0))
+          @pipes[i][:bytes_to_write] = @pipes[i][:reply].bytesize
+          bytes_written = FFI::MemoryPointer.new(:ulong)
+          success = WriteFile(@pipes[i][:instance], @pipes[i][:reply], @pipes[i][:bytes_to_write], bytes_written, @pipes[i][:overlap].to_ptr)
+
+          if success && bytes_written.read_ulong == @pipes[i][:bytes_to_write]
+            @pipes[i][:pending_io] = false
+            @pipes[i][:state] = READING_STATE
+            next
+          end
+
+          err = GetLastError()
+
+          if !success && err == ERROR_IO_PENDING
+            @pipes[i][:pending_io] = true
+            next
+          end
+
+          disconnect_and_reconnect(i)
+        else
+          raise "Invalid pipe state."
+        end
+      end
+    end
+
+    def disconnect_and_reconnect(i)
+      FlushFileBuffers(@pipes[i][:instance])
+      STDERR.puts("DisconnectNamedPipe failed with #{GetLastError()}") if !DisconnectNamedPipe(@pipes[i][:instance])
+  
+      @pipes[i][:pending_io] = connect_to_new_client(i)
+      
+      @pipes[i][:state] = @pipes[i][:pending_io] ? CONNECTING_STATE : READING_STATE
+    end
+
+    def connect_to_new_client(i)
+      pending_io = false
+      @pipes[i][:request].clear
+      @pipes[i][:reply].clear
+      connected = ConnectNamedPipe(@pipes[i][:instance], @pipes[i][:overlap].to_ptr)
+      last_error = GetLastError()
+      raise "ConnectNamedPipe failed with #{last_error} - #{connected}" if connected != 0
+      
+      case last_error
+      when ERROR_IO_PENDING
+        pending_io = true
+      when ERROR_PIPE_CONNECTED
+        SetEvent(@pipes[i][:overlap][:hEvent])
+      when ERROR_SUCCESS
+        pending_io = true
+      else
+        raise "ConnectNamedPipe failed with error #{last_error}"
+      end
+
+      pending_io
+    end
+  end
+end

data/lib/opal-webpack-loader/templates/initializer.rb.erb

@@ -9,4 +9,6 @@ else
   OpalWebpackLoader.manifest_path = nil
   OpalWebpackLoader.use_manifest = false
 end
-<%= opal_load_path %>
+<%= opal_load_path %>
+
+Rails.autoloaders.main.ignore "#{__dir__}/../../app/opal" if Dir.exist? "#{__dir__}/../../app/opal"

data/lib/opal-webpack-loader/templates/package.json.erb

@@ -9,18 +9,18 @@
     "production_build": "<%= production_script %>"
   },
   "devDependencies": {
-    "compression-webpack-plugin": "^3.0.0",
-    "css-loader": "^3.2.0",
+    "compression-webpack-plugin": "^5.0.2",
+    "css-loader": "^5.2.4",
     "extra-watch-webpack-plugin": "^1.0.3",
-    "file-loader": "^5.0.2",
-    "node-sass": "^4.13.0",
-    "parallel-webpack": "^2.4.0",
-    "sass-loader": "^8.0.0",
-    "style-loader": "^1.0.0",
-    "terser-webpack-plugin": "^2.2.1",
-    "webpack": "^4.41.2",
-    "webpack-assets-manifest": "^3.1.1",
-    "webpack-cli": "^3.3.10",
-    "webpack-dev-server": "^3.9.0"
+    "file-loader": "^6.2.0",
+    "node-sass": "^6.0.0",
+    "parallel-webpack": "^2.6.0",
+    "sass-loader": "^10.0.5",
+    "style-loader": "^2.0.0",
+    "terser-webpack-plugin": "^4.2.3",
+    "webpack": "^4.46.0",
+    "webpack-assets-manifest": "^4.0.6",
+    "webpack-cli": "^4.7.0",
+    "webpack-dev-server": "^3.11.2"
   }
 }

data/lib/opal-webpack-loader/templates/production.js.erb

@@ -9,7 +9,7 @@ const common_config = {
     mode: "production",
     optimization: {
         minimize: true, // minimize
-        minimizer: [new TerserPlugin({ parallel: true, cache: true })]
+        minimizer: [new TerserPlugin({ parallel: true })]
     },
     performance: {
         maxAssetSize: 20000000,
@@ -26,8 +26,8 @@ const common_config = {
         ]
     },
     plugins: [
-        new CompressionPlugin({ test: /^((?!application_ssr).)*$/, cache: true }), // gzip compress, exclude application_ssr.js
-        new WebpackAssetsManifest({ publicPath: true, merge: true }) // generate manifest
+        new CompressionPlugin({ test: /^((?!application_ssr).)*$/ }), // gzip compress, exclude application_ssr.js
+        new WebpackAssetsManifest({ publicPath: true, merge: true, output: 'manifest.json' }) // generate manifest
     ],
     module: {
         rules: [

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

@@ -1,3 +1,3 @@
-module OpalWebpackLoader
-  VERSION="0.9.11"
-end
+module OpalWebpackLoader
+  VERSION="0.11.0"
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: opal-webpack-loader
 version: !ruby/object:Gem::Version
-  version: 0.9.11
+  version: 0.11.0
 platform: ruby
 authors:
 - Jan Biedermann
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-03-01 00:00:00.000000000 Z
+date: 2021-05-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: opal
@@ -52,34 +52,48 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 2.7.0
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.15.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.15.0
 - !ruby/object:Gem::Dependency
   name: oj
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.7.0
+        version: 3.11.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.7.0
+        version: 3.11.0
 - !ruby/object:Gem::Dependency
   name: redis
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.1.0
+        version: 4.2.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.1.0
+        version: 4.2.0
 - !ruby/object:Gem::Dependency
   name: thor
   requirement: !ruby/object:Gem::Requirement
@@ -142,28 +156,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 5.2.3
+        version: 6.1.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 5.2.3
+        version: 6.1.0
 - !ruby/object:Gem::Dependency
   name: roda
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.19.0
+        version: 3.43.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.19.0
+        version: 3.43.0
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -184,14 +198,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.0.0
+        version: 5.3.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.0.0
+        version: 5.3.0
 description: "Bundle assets with webpack, resolve and compile opal ruby files\nand
   import them in the bundle, without sprockets or the webpacker gem\n(but can be used
   with both of them too). \nComes with a installer for rails and other frameworks.\n"
@@ -200,11 +214,16 @@ executables:
 - opal-webpack-compile-server
 - owl-install
 - owl-gen-loadpath-cache
+- owl-compiler
+- opal-webpack-windows-compile-server
 extensions: []
 extra_rdoc_files: []
 files:
 - LICENSE
+- README.md
 - bin/opal-webpack-compile-server
+- bin/opal-webpack-windows-compile-server
+- bin/owl-compiler
 - bin/owl-gen-loadpath-cache
 - bin/owl-install
 - lib/opal-webpack-loader.rb
@@ -213,6 +232,7 @@ files:
 - lib/opal-webpack-loader/installer_cli.rb
 - lib/opal-webpack-loader/load_path_manager.rb
 - lib/opal-webpack-loader/manifest.rb
+- lib/opal-webpack-loader/pipe_server.rb
 - lib/opal-webpack-loader/rails_view_helper.rb
 - lib/opal-webpack-loader/templates/Procfile.erb
 - lib/opal-webpack-loader/templates/app_loader.rb.erb
@@ -237,7 +257,7 @@ licenses:
 - MIT
 metadata:
   github_repo: ssh://github.com/isomorfeus/gems
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -252,8 +272,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
-signing_key: 
+rubygems_version: 3.2.15
+signing_key:
 specification_version: 4
 summary: Bundle assets with webpack, resolve and compile opal ruby files and import
   them in the bundle.