jass 0.9.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 629e1c61462902cabd2974f9723a17103f2fcc808813acdf9d052df264040196
+  data.tar.gz: e23194bf067a15162f0a421d86323b685225beeb461b5d7c762b9ea258c790ce
+SHA512:
+  metadata.gz: 82630076d46e54b547ebac6549840d4a29bb54831b528ffb23aed13dd359548e0c7672a09f044ffabf09af6c7f5c7107b3121eed7e6c1270a695097417e9a5a7
+  data.tar.gz: 2b31b59f675ac7b88e794db22dfefab2f119818a408510dd850f7e5e2d4de1da0eb6c734c77c84d368746af0f4ac8886f3b11aa7f8351c9b6992fc01e65db56d

data/LICENSE

@@ -0,0 +1,47 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Matthias Grosser
+
+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.
+
+
+
+Schmooze license
+
+The MIT License (MIT)
+
+Copyright (c) 2016 Shopify Inc.
+
+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/README.md

@@ -0,0 +1,45 @@
+# Jass
+
+Roll ES6 with the Rails asset pipeline - no Webpack required!
+
+Jass integrates Rollup.js, Bublé and Nodent with the Rails asset pipeline.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'jass'
+```
+
+You need a working NodeJS installation.
+
+## Configuration
+
+In Rails apps the location of your custom npm dependencies will be automatically
+set to:
+
+```
+Jass.vendor_modules_root = Rails.root.join('vendor')
+```
+
+For other frameworks, it needs to be set manually using the above method.
+
+## Usage
+
+Use `yarn` to install your custom npm dependencies into `vendor/node_modules`.
+`vendor/package.json` and `vendor/yarn.lock` should be checked into source control.
+
+Create your bundle entry points as `.jass` files under `app/assets/javascripts` in regular
+ES6 syntax (`import`, `async/await`).
+
+External dependencies can be declared to Sprockets using the `global` comment:
+
+```js
+// application.jass
+//= global vue Vue
+//= global vue-router VueRouter
+
+import Vue from 'vue'
+import Foo from 'custom-dependency'
+```

data/lib/jass.rb

@@ -0,0 +1,55 @@
+require 'set'
+require 'pathname'
+require 'open3'
+
+require 'sprockets'
+require 'active_support/all'
+
+module Jass
+  class << self
+    attr_accessor :vendor_modules_root, :plugins
+    
+    def modules_root
+      File.join(File.dirname(__FILE__), '..', 'vendor')
+    end
+    
+    def prepend_plugin(package, name, arguments = nil, root = nil)
+      Compiler.prepend_plugin(package, name, arguments, root)
+      @compiler = nil
+    end
+    
+    def compiler
+      @compiler ||= Jass::Compiler.new
+    end
+  end
+end
+
+require 'jass/version'
+require 'jass/errors'
+require 'jass/dependency'
+require 'jass/function'
+require 'jass/plugin'
+require 'jass/base'
+require 'jass/compiler'
+require 'jass/global_directive_processor'
+require 'jass/es6_processor'
+require 'jass/bundle_processor'
+
+require 'jass/railtie' if defined?(Rails)
+
+if Sprockets.respond_to?(:register_transformer)
+  Sprockets.register_mime_type 'text/ecmascript-6', extensions: %w[.jass], charset: :unicode
+  Sprockets.register_transformer 'text/ecmascript-6', 'application/javascript', Jass::BundleProcessor
+end
+
+if Sprockets.respond_to?(:register_engine)
+#  args = ['.es6', Jass::ES6Processor]
+#  args << { mime_type: 'text/ecmascript-6', silence_deprecation: true } if Sprockets::VERSION.start_with?("3")
+#  Sprockets.register_engine(*args)
+  
+  args = ['.jass', Jass::BundleProcessor]
+  args << { mime_type: 'text/ecmascript-6', silence_deprecation: true } if Sprockets::VERSION.start_with?("3")
+  Sprockets.register_engine(*args)
+end
+
+Sprockets.register_preprocessor 'text/ecmascript-6', Jass::GlobalDirectiveProcessor

data/lib/jass/base.rb

@@ -0,0 +1,141 @@
+module Jass
+  class Base
+    
+    class_attribute :dependencies
+    self.dependencies = []
+    
+    class_attribute :functions
+    self.functions = []
+    
+    class_attribute :plugins
+    self.plugins = []
+    
+    class << self
+      def dependency(deps)
+        self.dependencies = dependencies + deps.map { |name, package| Dependency.new(name, package) }
+      end
+
+      def function(name, code)
+        self.functions = functions + [Function.new(name, code)]
+        define_method(name) { |*args| call_js_method(name, args) }
+      end
+
+      def generate_code
+        %{
+          function __handle_error__(error) {
+            var errInfo = {};
+            if (error instanceof Error) {
+              errInfo.name = error.name;
+              Object.getOwnPropertyNames(error).reduce((obj, prop) => { obj[prop] = error[prop]; return obj }, errInfo);
+              // process.stdout.write(JSON.stringify(['err', error.toString().replace(new RegExp('^' + error.name + ': '), ''), error.name]));
+            } else {
+              errInfo.name = error.toString();
+            }
+            process.stdout.write(JSON.stringify(['err', errInfo]));
+            process.stdout.write("\\n");
+          }
+
+          try {
+            #{dependencies.map(&:to_js).join}
+          } catch (e) {
+            __handle_error__(e);
+            process.exit(1);
+          }
+        
+          var __plugins__ = [];
+          #{plugins.map(&:to_js).join}
+        
+          process.stdout.write("[\\"ok\\"]\\n");
+        
+          var __methods__ = {};
+          #{functions.map(&:to_js).join}
+        
+          require('readline').createInterface({
+            input: process.stdin,
+            terminal: false,
+          }).on('line', function(line) {
+            var input = JSON.parse(line);
+            try {
+              Promise.resolve(__methods__[input[0]].apply(null, input[1])
+              ).then(function (result) {
+                process.stdout.write(JSON.stringify(['ok', result]));
+                process.stdout.write("\\n");
+              }).catch(__handle_error__);
+            } catch(error) {
+              __handle_error__(error);
+            }
+          });
+        }
+      end
+
+      protected
+
+      def finalize(stdin, stdout, stderr, process_thread)
+        proc do
+          stdin.close
+          stdout.close
+          stderr.close
+          Process.kill(0, process_thread.pid)
+          process_thread.value
+        end
+      end
+    end
+
+    def initialize(root, env = {})
+      @node_root = root
+      @node_env = env
+    end
+
+    def pid
+      @node_process_thread && @node_process_thread.pid
+    end
+
+    private
+    
+    def ensure_process_is_spawned
+      return if @node_process_thread
+      spawn_process
+    end
+
+    def spawn_process
+      process_data = Open3.popen3(@node_env, 'node', '-e', self.class.generate_code, chdir: @node_root)
+      ensure_packages_are_initiated(*process_data)
+      ObjectSpace.define_finalizer(self, self.class.send(:finalize, *process_data))
+      @node_stdin, @node_stdout, @node_stderr, @node_process_thread = process_data
+    end
+
+    def ensure_packages_are_initiated(stdin, stdout, stderr, process_thread)
+      input = stdout.gets
+      raise Jass::Error, "Failed to instantiate Node process:\n#{stderr.read}" if input.nil?
+      result = JSON.parse(input)
+      unless result[0] == 'ok'
+        stdin.close
+        stdout.close
+        stderr.close
+        process_thread.join
+
+        error = result[1]
+        if error.is_a?(Hash)
+          raise Jass::DependencyError.new(error)
+        elsif error.is_a?(String)
+          raise Jass::Error, error
+        end
+      end
+    end
+    
+    def call_js_method(method, args)
+      ensure_process_is_spawned
+
+      @node_stdin.puts JSON.dump([method, args])
+      input = @node_stdout.gets
+      raise Errno::EPIPE, "Can't read from stdout" if input.nil?
+      status, result = JSON.parse(input)
+      return result if status == 'ok'
+      raise Jass::JavaScriptError.new(result)
+    rescue Errno::EPIPE, IOError
+      # TODO(bouk): restart or something? If this happens the process is completely broken
+      raise Jass::Error, "Node process failed:\n#{@node_stderr.read}"
+    end
+    
+  end
+end

data/lib/jass/bundle_processor.rb

@@ -0,0 +1,28 @@
+module Jass
+  class BundleProcessor
+    
+    class << self
+      def instance
+        @instance ||= new
+      end
+      
+      def call(input)
+        instance.call(input)
+      end
+    end
+    
+    def call(input)
+      env, filename = input.fetch(:environment), input.fetch(:filename)
+      dependencies = Set.new(input.fetch(:metadata).fetch(:dependencies))
+      globals = input.fetch(:metadata).fetch(:globals, {})
+      bundle_root = Pathname.new(filename).dirname
+      bundle = Jass.compiler.bundle(filename, {}, globals: globals)
+      dependencies += bundle.fetch('map').fetch('sources').map { |dep| Sprockets::URIUtils.build_file_digest_uri(bundle_root.join(dep).to_s) }
+      
+      { data: bundle.fetch('code'),
+        dependencies: dependencies,
+        map: bundle.fetch('map') }
+    end
+    
+  end
+end

data/lib/jass/compiler.rb

@@ -0,0 +1,112 @@
+module Jass
+  class Compiler < Base
+    dependency buble: 'buble',
+               NodentCompiler: 'nodent-compiler',
+               rollup: 'rollup',
+               nodeResolve: 'rollup-plugin-node-resolve',
+               commonjs: 'rollup-plugin-commonjs'
+
+    function :init, <<~JS
+      function () {
+        global.nodent_compiler = new NodentCompiler;
+        global.send = function() {
+          var args = [...arguments];
+          var method = args.shift();
+          return __methods__[method].apply(null, args);
+        }
+      }
+    JS
+    
+    function :nodent, <<~JS
+      function(src, filename) {
+        return global.nodent_compiler.compile(src, filename,
+          { es6target: true,
+            sourcemap: false,
+            parser: {
+              sourceType: 'script',
+              ecmaVersion: 9
+            },
+            promises: true,
+            noRuntime: true }).code;
+      }
+    JS
+
+    function :buble, <<~JS
+      function(src) {
+        return buble.transform(src,
+          { transforms: { dangerousForOf: true },
+            objectAssign: 'Object.assign' }).code;
+      }
+    JS
+    
+    # Compile ES6 without imports: buble(nodent(src))
+    function :compile, <<~JS
+      function(src, filename) {
+        return send('buble', send('nodent', src, filename));
+      }
+    JS
+
+    # Build bundle with imports: buble(rollup(nodent(src)))
+    function :js_bundle, <<~JS
+      function(entry, moduleDirectories, inputOptions, outputOptions) {
+        inputOptions = inputOptions || {};
+        outputOptions = outputOptions || {}
+        // TODO: throw error unless moduleDirectories
+        Object.assign(inputOptions,
+          { input: entry,
+            treeshake: false,
+            plugins: [
+              ...__plugins__,
+              nodeResolve({ customResolveOptions: { moduleDirectory: moduleDirectories }}),
+              commonjs()
+            ]
+          }
+        );
+        Object.assign(outputOptions,
+          { format: 'iife',
+            sourcemap: true,
+            exports: 'none'
+          }
+        );
+        var promise = rollup.rollup(inputOptions)
+            .then(bundle => bundle.generate(outputOptions))
+            .then(bundle => { return { code: send('compile', bundle.code), map: bundle.map }; });
+        return promise;
+      }
+    JS
+    
+    def bundle(entry, input_options = {}, output_options = {})
+      js_bundle(entry, self.class.node_paths, input_options, output_options)
+    end
+    
+    # Get vendor library versions
+    function :versions, <<~JS
+      function() {
+        return {  buble: buble.VERSION,
+                  rollup: rollup.VERSION,
+                  nodent: global.nodent_compiler.version };
+      }
+    JS
+
+    class << self
+      def prepend_plugin(package, name, arguments = nil, root = nil)
+        plugins.unshift(Plugin.new(name, arguments, root))
+        dependency name => package
+      end
+      
+      def node_paths
+        ([Jass.modules_root, Jass.vendor_modules_root] + plugins.map(&:root)).compact.map { |p| File.absolute_path(File.join(p, 'node_modules')) }
+      end
+      
+      def node_path
+        node_paths.join(':')
+      end
+    end
+    
+    def initialize
+      super(Jass.modules_root, 'NODE_PATH' => self.class.node_path)
+      init
+    end
+    
+  end
+end

data/lib/jass/dependency.rb

@@ -0,0 +1,14 @@
+module Jass
+  class Dependency
+    attr_reader :name, :package
+    
+    def initialize(name, package)
+      @name, @package = name, package
+    end
+  
+    def to_js
+      "var #{name} = require(#{package.to_json});\n"
+    end
+   
+  end
+end