webpacker-jets 3.2.100

data/lib/webpacker/instance.rb

@@ -0,0 +1,44 @@
+class Webpacker::Instance
+  cattr_accessor(:logger) { ActiveSupport::TaggedLogging.new(ActiveSupport::Logger.new(STDOUT)) }
+
+  attr_reader :root_path, :config_path
+
+  def initialize(root_path: Jets.root, config_path: Jets.root.join("config/webpacker.yml"))
+    @root_path, @config_path = root_path, config_path
+  end
+
+  def env
+    (ENV["NODE_ENV"].presence_in(available_environments) ||
+      Jets.env.presence_in(available_environments) ||
+        "production".freeze).inquiry
+  end
+
+  def config
+    @config ||= Webpacker::Configuration.new self
+  end
+
+  def compiler
+    @compiler ||= Webpacker::Compiler.new self
+  end
+
+  def dev_server
+    @dev_server ||= Webpacker::DevServer.new self
+  end
+
+  def manifest
+    @manifest ||= Webpacker::Manifest.new self
+  end
+
+  def commands
+    @commands ||= Webpacker::Commands.new self
+  end
+
+  private
+    def available_environments
+      if config_path.exist?
+        YAML.load(config_path.read).keys
+      else
+        [].freeze
+      end
+    end
+end

data/lib/webpacker/manifest.rb

@@ -0,0 +1,75 @@
+# Singleton registry for accessing the packs path using a generated manifest.
+# This allows javascript_pack_tag, stylesheet_pack_tag, asset_pack_path to take a reference to,
+# say, "calendar.js" or "calendar.css" and turn it into "/packs/calendar-1016838bab065ae1e314.js" or
+# "/packs/calendar-1016838bab065ae1e314.css".
+#
+# When the configuration is set to on-demand compilation, with the `compile: true` option in
+# the webpacker.yml file, any lookups will be preceeded by a compilation if one is needed.
+class Webpacker::Manifest
+  class MissingEntryError < StandardError; end
+
+  delegate :config, :compiler, :dev_server, to: :@webpacker
+
+  def initialize(webpacker)
+    @webpacker = webpacker
+  end
+
+  def refresh
+    @data = load
+  end
+
+  def lookup(name)
+    compile if compiling?
+    find name
+  end
+
+  def lookup!(name)
+    lookup(name) || handle_missing_entry(name)
+  end
+
+  private
+    def compiling?
+      config.compile? && !dev_server.running?
+    end
+
+    def compile
+      Webpacker.logger.tagged("Webpacker") { compiler.compile }
+    end
+
+    def find(name)
+      data[name.to_s].presence
+    end
+
+    def handle_missing_entry(name)
+      raise Webpacker::Manifest::MissingEntryError, missing_file_from_manifest_error(name)
+    end
+
+    def missing_file_from_manifest_error(bundle_name)
+      <<-MSG
+Webpacker can't find #{bundle_name} in #{config.public_manifest_path}. Possible causes:
+1. You want to set webpacker.yml value of compile to true for your environment
+   unless you are using the `webpack -w` or the webpack-dev-server.
+2. webpack has not yet re-run to reflect updates.
+3. You have misconfigured Webpacker's config/webpacker.yml file.
+4. Your webpack configuration is not creating a manifest.
+Your manifest contains:
+#{JSON.pretty_generate(@data)}
+      MSG
+    end
+
+    def data
+      if config.cache_manifest?
+        @data ||= load
+      else
+        refresh
+      end
+    end
+
+    def load
+      if config.public_manifest_path.exist?
+        JSON.parse config.public_manifest_path.read
+      else
+        {}
+      end
+    end
+end

data/lib/webpacker/railtie.rb

@@ -0,0 +1,82 @@
+require "rails/railtie"
+
+require "webpacker/helper"
+require "webpacker/dev_server_proxy"
+
+class Webpacker::Engine < ::Rails::Engine
+  # Allows Webpacker config values to be set via Rails env config files
+  config.webpacker = ActiveSupport::OrderedOptions.new
+  config.webpacker.check_yarn_integrity = false
+
+  # ================================
+  # Check Yarn Integrity Initializer
+  # ================================
+  #
+  # development (on by default):
+  #
+  #    to turn off:
+  #     - edit config/environments/development.rb
+  #     - add `config.webpacker.check_yarn_integrity = false`
+  #
+  # production (off by default):
+  #
+  #    to turn on:
+  #     - edit config/environments/production.rb
+  #     - add `config.webpacker.check_yarn_integrity = false`
+  initializer "webpacker.yarn_check" do |app|
+    if File.exist?("yarn.lock") && app.config.webpacker.check_yarn_integrity
+      output = `yarn check --integrity 2>&1`
+
+      unless $?.success?
+        warn "\n\n"
+        warn "========================================"
+        warn "  Your Yarn packages are out of date!"
+        warn "  Please run `yarn install` to update."
+        warn "========================================"
+        warn "\n\n"
+        warn "To disable this check, please add `config.webpacker.check_yarn_integrity = false`"
+        warn "to your Rails development config file (config/environments/development.rb)."
+        warn "\n\n"
+        warn output
+        warn "\n\n"
+
+        exit(1)
+      end
+    end
+  end
+
+  initializer "webpacker.proxy" do |app|
+    if Rails.env.development?
+      app.middleware.insert_before 0,
+        Rails::VERSION::MAJOR >= 5 ?
+          Webpacker::DevServerProxy : "Webpacker::DevServerProxy", ssl_verify_none: true
+    end
+  end
+
+  initializer "webpacker.helper" do
+    ActiveSupport.on_load :action_controller do
+      ActionController::Base.helper Webpacker::Helper
+    end
+
+    ActiveSupport.on_load :action_view do
+      include Webpacker::Helper
+    end
+  end
+
+  initializer "webpacker.logger" do
+    config.after_initialize do
+      if ::Rails.logger.respond_to?(:tagged)
+        Webpacker.logger = ::Rails.logger
+      else
+        Webpacker.logger = ActiveSupport::TaggedLogging.new(::Rails.logger)
+      end
+    end
+  end
+
+  initializer "webpacker.bootstrap" do
+    if defined?(Rails::Server) || defined?(Rails::Console)
+      Webpacker.bootstrap
+      Spring.after_fork { Webpacker.bootstrap } if defined?(Spring)
+    end
+  end
+end

data/lib/webpacker/rake_tasks.rb

@@ -0,0 +1,6 @@
+class Webpacker::RakeTasks
+  def self.load!
+    tasks_path = File.expand_path("../tasks", __dir__)
+    Dir.glob("#{tasks_path}/**/*.rake").sort.each { |ext| load ext }
+  end
+end

data/lib/webpacker/runner.rb

@@ -0,0 +1,22 @@
+module Webpacker
+  class Runner
+    def self.run(argv)
+      $stdout.sync = true
+
+      new(argv).run
+    end
+
+    def initialize(argv)
+      @argv = argv
+
+      @app_path          = File.expand_path(".", Dir.pwd)
+      @node_modules_path = File.join(@app_path, "node_modules")
+      @webpack_config    = File.join(@app_path, "config/webpack/#{ENV["NODE_ENV"]}.js")
+
+      unless File.exist?(@webpack_config)
+        $stderr.puts "webpack config #{@webpack_config} not found, please run 'jets webpacker:install' to install Webpacker with default configs or add the missing config file for your custom environment."
+        exit!
+      end
+    end
+  end
+end

data/lib/webpacker/version.rb

@@ -0,0 +1,9 @@
+module Webpacker
+  # Change the version in package.json too, please!
+  # Since this fork and branch originally started from rails/webpacker
+  # The git tags collide. As a hacky workaround adding 100 to the patch version.
+  # Example:
+  #  webpacker-jets 3.2.100 # added 100 to the patch version
+  #  webpacker 3.2.0 # original
+  VERSION = "3.2.100".freeze
+end

data/lib/webpacker/webpack_runner.rb

@@ -0,0 +1,15 @@
+require "shellwords"
+require "webpacker/runner"
+
+module Webpacker
+  class WebpackRunner < Webpacker::Runner
+    def run
+      env = { "NODE_PATH" => @node_modules_path.shellescape }
+      cmd = [ "#{@node_modules_path}/.bin/webpack", "--config", @webpack_config ] + @argv
+
+      Dir.chdir(@app_path) do
+        exec env, *cmd
+      end
+    end
+  end
+end

data/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@rails/webpacker",
+  "version": "3.2.0",
+  "description": "Use webpack to manage app-like JavaScript modules in Rails",
+  "main": "package/index.js",
+  "files": [
+    "package",
+    "lib/install/config/webpacker.yml"
+  ],
+  "engines": {
+    "node": ">=6.0.0",
+    "yarn": ">=0.25.2"
+  },
+  "dependencies": {
+    "babel-core": "^6.26.0",
+    "babel-loader": "^7.1.2",
+    "babel-plugin-syntax-dynamic-import": "^6.18.0",
+    "babel-plugin-transform-class-properties": "^6.24.1",
+    "babel-plugin-transform-object-rest-spread": "^6.26.0",
+    "babel-polyfill": "^6.26.0",
+    "babel-preset-env": "^1.6.1",
+    "case-sensitive-paths-webpack-plugin": "^2.1.1",
+    "compression-webpack-plugin": "^1.0.1",
+    "css-loader": "^0.28.7",
+    "extract-text-webpack-plugin": "^3.0.2",
+    "file-loader": "^1.1.5",
+    "glob": "^7.1.2",
+    "js-yaml": "^3.10.0",
+    "node-sass": "^4.7.2",
+    "path-complete-extname": "^0.1.0",
+    "postcss-cssnext": "^3.0.2",
+    "postcss-import": "^11.0.0",
+    "postcss-loader": "^2.0.9",
+    "sass-loader": "^6.0.6",
+    "style-loader": "^0.19.0",
+    "webpack": "^3.10.0",
+    "webpack-manifest-plugin": "^1.3.2"
+  },
+  "devDependencies": {
+    "eslint": "^4.13.0",
+    "eslint-config-airbnb": "^16.1.0",
+    "eslint-plugin-import": "^2.8.0",
+    "eslint-plugin-jsx-a11y": "^6.0.2",
+    "eslint-plugin-react": "^7.5.1",
+    "jest": "^21.2.1"
+  },
+  "jest": {
+    "testRegex": "(/__tests__/.*|(\\.|/))\\.jsx?$",
+    "roots": [
+      "<rootDir>/package"
+    ]
+  },
+  "scripts": {
+    "test": "jest",
+    "lint": "eslint {package,lib}/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rails/webpacker.git"
+  },
+  "author": "David Heinemeier Hansson <david@basecamp.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/rails/webpacker/issues"
+  },
+  "homepage": "https://github.com/rails/webpacker"
+}

data/package/__tests__/environment.js

@@ -0,0 +1,74 @@
+/* global test expect, describe, afterAll, beforeEach */
+
+// environment.js expects to find config/webpacker.yml and resolved modules from
+// the root of a Rails project
+
+const chdirApp = () => process.chdir('test/test_app')
+const chdirCwd = () => process.chdir(process.cwd())
+chdirApp()
+
+const { resolve } = require('path')
+const rules = require('../rules')
+const { ConfigList } = require('../config_types')
+const Environment = require('../environment')
+
+describe('Environment', () => {
+  afterAll(chdirCwd)
+
+  let environment
+
+  describe('toWebpackConfig', () => {
+    beforeEach(() => {
+      environment = new Environment()
+    })
+
+    test('should return entry', () => {
+      const config = environment.toWebpackConfig()
+      expect(config.entry.application).toEqual(resolve('app', 'javascript', 'packs', 'application.js'))
+    })
+
+    test('should return output', () => {
+      const config = environment.toWebpackConfig()
+      expect(config.output.filename).toEqual('[name]-[chunkhash].js')
+      expect(config.output.chunkFilename).toEqual('[name]-[chunkhash].chunk.js')
+      expect(config.output.path).toEqual(resolve('public', 'packs-test'))
+      expect(config.output.publicPath).toEqual('/packs-test/')
+    })
+
+    test('should return default loader rules for each file in config/loaders', () => {
+      const config = environment.toWebpackConfig()
+      const defaultRules = Object.keys(rules)
+      const configRules = config.module.rules
+
+      expect(defaultRules.length).toBeGreaterThan(1)
+      expect(configRules.length).toEqual(defaultRules.length)
+    })
+
+    test('should return default plugins', () => {
+      const config = environment.toWebpackConfig()
+      expect(config.plugins.length).toEqual(4)
+    })
+
+    test('should return default resolveLoader', () => {
+      const config = environment.toWebpackConfig()
+      expect(config.resolveLoader.modules).toEqual(['node_modules'])
+    })
+
+    test('should return default resolve.modules with additions', () => {
+      const config = environment.toWebpackConfig()
+      expect(config.resolve.modules).toEqual([
+        resolve('app', 'javascript'),
+        resolve('app/assets'),
+        resolve('/etc/yarn'),
+        'node_modules'
+      ])
+    })
+
+    test('returns plugins property as Array', () => {
+      const config = environment.toWebpackConfig()
+
+      expect(config.plugins).toBeInstanceOf(Array)
+      expect(config.plugins).not.toBeInstanceOf(ConfigList)
+    })
+  })
+})

data/package/config.js

@@ -0,0 +1,34 @@
+const { resolve } = require('path')
+const { safeLoad } = require('js-yaml')
+const { readFileSync } = require('fs')
+const deepMerge = require('./utils/deep_merge')
+
+const defaultFilePath = require.resolve('../lib/install/config/webpacker.yml')
+const filePath = resolve('config', 'webpacker.yml')
+
+const environment = process.env.NODE_ENV || 'development'
+const defaultConfig = safeLoad(readFileSync(defaultFilePath), 'utf8')[environment]
+const appConfig = safeLoad(readFileSync(filePath), 'utf8')[environment]
+const config = deepMerge(defaultConfig, appConfig)
+
+const isBoolean = str => /^true/.test(str) || /^false/.test(str)
+
+const fetch = key =>
+  (isBoolean(process.env[key]) ? JSON.parse(process.env[key]) : process.env[key])
+
+const devServer = (key) => {
+  const envValue = fetch(`WEBPACKER_DEV_SERVER_${key.toUpperCase().replace(/_/g, '')}`)
+  if (typeof envValue === 'undefined' || envValue === null) return config.dev_server[key]
+  return envValue
+}
+
+if (config.dev_server) {
+  Object.keys(config.dev_server).forEach((key) => {
+    config.dev_server[key] = devServer(key)
+  })
+}
+
+config.outputPath = resolve('public', config.public_output_path)
+config.publicPath = `/${config.public_output_path}/`.replace(/([^:]\/)\/+/g, '$1')
+
+module.exports = config

data/package/config_types/__tests__/config_list.js

@@ -0,0 +1,123 @@
+/* global test expect */
+
+const ConfigList = require('../config_list')
+
+test('new', () => {
+  const list = new ConfigList()
+  expect(list).toBeInstanceOf(ConfigList)
+  expect(list).toBeInstanceOf(Array)
+})
+
+test('set', () => {
+  const list = new ConfigList()
+  expect(list.set('key', 'value')).toEqual([{ key: 'key', value: 'value' }])
+})
+
+test('get', () => {
+  const list = new ConfigList()
+  list.append('key', 'value')
+  expect(list.get('key')).toEqual('value')
+})
+
+test('append', () => {
+  const list = new ConfigList()
+  list.append('key', 'value')
+  expect(list.append('key1', 'value1')).toEqual([
+    { key: 'key', value: 'value' },
+    { key: 'key1', value: 'value1' }
+  ])
+})
+
+test('prepend', () => {
+  const list = new ConfigList()
+  list.append('key', 'value')
+  expect(list.prepend('key1', 'value1')).toEqual([
+    { key: 'key1', value: 'value1' },
+    { key: 'key', value: 'value' }
+  ])
+})
+
+test('insert without position', () => {
+  const list = new ConfigList()
+  list.append('key', 'value')
+
+  expect(list.insert('key1', 'value1')).toEqual([
+    { key: 'key', value: 'value' },
+    { key: 'key1', value: 'value1' }
+  ])
+
+  expect(list.insert('key2', 'value2')).toEqual([
+    { key: 'key', value: 'value' },
+    { key: 'key1', value: 'value1' },
+    { key: 'key2', value: 'value2' }
+  ])
+})
+
+test('insert before an item', () => {
+  const list = new ConfigList()
+  list.append('key', 'value')
+  list.append('key1', 'value1')
+
+  expect(list.insert('key2', 'value2', { before: 'key' })).toEqual([
+    { key: 'key2', value: 'value2' },
+    { key: 'key', value: 'value' },
+    { key: 'key1', value: 'value1' }
+  ])
+
+  expect(list.insert('key3', 'value3', { before: 'key2' })).toEqual([
+    { key: 'key3', value: 'value3' },
+    { key: 'key2', value: 'value2' },
+    { key: 'key', value: 'value' },
+    { key: 'key1', value: 'value1' }
+  ])
+})
+
+test('insert after an item', () => {
+  const list = new ConfigList()
+  list.append('key', 'value')
+  list.append('key1', 'value1')
+
+  expect(list.insert('key2', 'value2', { after: 'key' })).toEqual([
+    { key: 'key', value: 'value' },
+    { key: 'key2', value: 'value2' },
+    { key: 'key1', value: 'value1' }
+  ])
+
+  expect(list.insert('key3', 'value3', { after: 'key2' })).toEqual([
+    { key: 'key', value: 'value' },
+    { key: 'key2', value: 'value2' },
+    { key: 'key3', value: 'value3' },
+    { key: 'key1', value: 'value1' }
+  ])
+})
+
+test('delete', () => {
+  const list = new ConfigList()
+  list.append('key', 'value')
+  list.append('key1', 'value1')
+  expect(list.delete('key')).toEqual([{ key: 'key1', value: 'value1' }])
+  expect(list.delete('key1')).toEqual([])
+})
+
+test('getIndex', () => {
+  const list = new ConfigList()
+  list.append('key', 'value')
+  list.append('key1', 'value1')
+  expect(list.getIndex('key')).toEqual(0)
+  expect(list.getIndex('key2')).toEqual(-1)
+  expect(() => list.getIndex('key2', true)).toThrow('Item key2 not found')
+})
+
+test('values', () => {
+  const list = new ConfigList()
+  list.append('key', 'value')
+  list.append('key1', 'value1')
+  expect(list.values()).toEqual(['value', 'value1'])
+})
+
+test('keys', () => {
+  const list = new ConfigList()
+  list.append('key', 'value')
+  list.append('key1', 'value1')
+  expect(list.keys()).toEqual(['key', 'key1'])
+})