shakapacker 6.0.0.rc.6

data/lib/webpacker/commands.rb

@@ -0,0 +1,79 @@
+class Webpacker::Commands
+  delegate :config, :compiler, :manifest, :logger, to: :@webpacker
+
+  def initialize(webpacker)
+    @webpacker = webpacker
+  end
+
+  # Cleanup old assets in the compile directory. By default it will
+  # keep the latest version, 2 backups created within the past hour.
+  #
+  # Examples
+  #
+  #   To force only 1 backup to be kept, set count=1 and age=0.
+  #
+  #   To only keep files created within the last 10 minutes, set count=0 and
+  #   age=600.
+  #
+  def clean(count = 2, age = 3600)
+    if config.public_output_path.exist? && config.public_manifest_path.exist?
+      packs
+        .map do |paths|
+          paths.map { |path| [Time.now - File.mtime(path), path] }
+          .sort
+          .reject.with_index do |(file_age, _), index|
+            file_age < age || index < count
+          end
+          .map { |_, path| path }
+        end
+        .flatten
+        .compact
+        .each do |file|
+          if File.file?(file)
+            File.delete(file)
+            logger.info "Removed #{file}"
+          end
+        end
+    end
+
+    true
+  end
+
+  def clobber
+    config.public_output_path.rmtree if config.public_output_path.exist?
+    config.cache_path.rmtree if config.cache_path.exist?
+  end
+
+  def bootstrap
+    manifest.refresh
+  end
+
+  def compile
+    compiler.compile.tap do |success|
+      manifest.refresh if success
+    end
+  end
+
+  private
+    def packs
+      all_files       = Dir.glob("#{config.public_output_path}/**/*")
+      manifest_config = Dir.glob("#{config.public_manifest_path}*")
+
+      packs = all_files - manifest_config - current_version
+      packs.reject { |file| File.directory?(file) }.group_by do |path|
+        base, _, ext = File.basename(path).scan(/(.*)(-[\da-f]+)(\.\w+)/).flatten
+        "#{File.dirname(path)}/#{base}#{ext}"
+      end.values
+    end
+
+    def current_version
+      packs = manifest.refresh.values.map do |value|
+        value = value["src"] if value.is_a?(Hash)
+        next unless value.is_a?(String)
+
+        File.join(config.root_path, "public", "#{value}*")
+      end.compact
+
+      Dir.glob(packs).uniq
+    end
+end

data/lib/webpacker/compiler.rb

@@ -0,0 +1,130 @@
+require "open3"
+require "digest/sha1"
+
+class Webpacker::Compiler
+  # Additional paths that test compiler needs to watch
+  # Webpacker::Compiler.watched_paths << 'bower_components'
+  #
+  # Deprecated. Use additional_paths in the YAML configuration instead.
+  cattr_accessor(:watched_paths) { [] }
+
+  # Additional environment variables that the compiler is being run with
+  # Webpacker::Compiler.env['FRONTEND_API_KEY'] = 'your_secret_key'
+  cattr_accessor(:env) { {} }
+
+  delegate :config, :logger, to: :webpacker
+
+  def initialize(webpacker)
+    @webpacker = webpacker
+  end
+
+  def compile
+    if stale?
+      run_webpack.tap do |success|
+        # We used to only record the digest on success
+        # However, the output file is still written on error, meaning that the digest should still be updated.
+        # If it's not, you can end up in a situation where a recompile doesn't take place when it should.
+        # See https://github.com/rails/webpacker/issues/2113
+        record_compilation_digest
+      end
+    else
+      logger.debug "Everything's up-to-date. Nothing to do"
+      true
+    end
+  end
+
+  # Returns true if all the compiled packs are up to date with the underlying asset files.
+  def fresh?
+    last_compilation_digest&.== watched_files_digest
+  end
+
+  # Returns true if the compiled packs are out of date with the underlying asset files.
+  def stale?
+    !fresh?
+  end
+
+  private
+    attr_reader :webpacker
+
+    def last_compilation_digest
+      compilation_digest_path.read if compilation_digest_path.exist? && config.public_manifest_path.exist?
+    rescue Errno::ENOENT, Errno::ENOTDIR
+    end
+
+    def watched_files_digest
+      if Rails.env.development?
+        warn <<~MSG.strip
+          Webpacker::Compiler - Slow setup for development
+
+          Prepare JS assets with either:
+          1. Running `bin/webpack-dev-server`
+          2. Set `compile` to false in webpacker.yml and run `bin/webpack -w`
+        MSG
+      end
+
+      warn "Webpacker::Compiler.watched_paths has been deprecated. Set additional_paths in webpacker.yml instead." unless watched_paths.empty?
+      root_path = Pathname.new(File.expand_path(config.root_path))
+      expanded_paths = [*default_watched_paths, *watched_paths].map do |path|
+        root_path.join(path)
+      end
+      files = Dir[*expanded_paths].reject { |f| File.directory?(f) }
+      file_ids = files.sort.map { |f| "#{File.basename(f)}/#{Digest::SHA1.file(f).hexdigest}" }
+      Digest::SHA1.hexdigest(file_ids.join("/"))
+    end
+
+    def record_compilation_digest
+      config.cache_path.mkpath
+      compilation_digest_path.write(watched_files_digest)
+    end
+
+    def optionalRubyRunner
+      bin_webpack_path = config.root_path.join("bin/webpacker")
+      first_line = File.readlines(bin_webpack_path).first.chomp
+      /ruby/.match?(first_line) ? RbConfig.ruby : ""
+    end
+
+    def run_webpack
+      logger.info "Compiling..."
+
+      stdout, stderr, status = Open3.capture3(
+        webpack_env,
+        "#{optionalRubyRunner} ./bin/webpacker",
+        chdir: File.expand_path(config.root_path)
+      )
+
+      if status.success?
+        logger.info "Compiled all packs in #{config.public_output_path}"
+        logger.error "#{stderr}" unless stderr.empty?
+
+        if config.webpack_compile_output?
+          logger.info stdout
+        end
+      else
+        non_empty_streams = [stdout, stderr].delete_if(&:empty?)
+        logger.error "\nCOMPILATION FAILED:\nEXIT STATUS: #{status}\nOUTPUTS:\n#{non_empty_streams.join("\n\n")}"
+      end
+
+      status.success?
+    end
+
+    def default_watched_paths
+      [
+        *config.additional_paths,
+        "#{config.source_path}/**/*",
+        "yarn.lock", "package.json",
+        "config/webpack/**/*"
+      ].freeze
+    end
+
+    def compilation_digest_path
+      config.cache_path.join("last-compilation-digest-#{webpacker.env}")
+    end
+
+    def webpack_env
+      return env unless defined?(ActionController::Base)
+
+      env.merge("WEBPACKER_ASSET_HOST"        => ENV.fetch("WEBPACKER_ASSET_HOST", ActionController::Base.helpers.compute_asset_host),
+                "WEBPACKER_RELATIVE_URL_ROOT" => ENV.fetch("WEBPACKER_RELATIVE_URL_ROOT", ActionController::Base.relative_url_root),
+                "WEBPACKER_CONFIG" => webpacker.config_path.to_s)
+    end
+end

data/lib/webpacker/configuration.rb

@@ -0,0 +1,111 @@
+require "yaml"
+require "active_support/core_ext/hash/keys"
+require "active_support/core_ext/hash/indifferent_access"
+
+class Webpacker::Configuration
+  class << self
+    attr_accessor :installing
+  end
+
+  attr_reader :root_path, :config_path, :env
+
+  def initialize(root_path:, config_path:, env:)
+    @root_path = root_path
+    @config_path = config_path
+    @env = env
+  end
+
+  def dev_server
+    fetch(:dev_server)
+  end
+
+  def compile?
+    fetch(:compile)
+  end
+
+  def source_path
+    root_path.join(fetch(:source_path))
+  end
+
+  def additional_paths
+    fetch(:additional_paths)
+  end
+
+  def source_entry_path
+    source_path.join(fetch(:source_entry_path))
+  end
+
+  def public_path
+    root_path.join(fetch(:public_root_path))
+  end
+
+  def public_output_path
+    public_path.join(fetch(:public_output_path))
+  end
+
+  def public_manifest_path
+    public_output_path.join("manifest.json")
+  end
+
+  def cache_manifest?
+    fetch(:cache_manifest)
+  end
+
+  def cache_path
+    root_path.join(fetch(:cache_path))
+  end
+
+  def check_yarn_integrity=(value)
+    warn <<~EOS
+      Webpacker::Configuration#check_yarn_integrity=(value) is obsolete. The integrity
+      check has been removed from Webpacker (https://github.com/rails/webpacker/pull/2518)
+      so changing this setting will have no effect.
+    EOS
+  end
+
+  def webpack_compile_output?
+    fetch(:webpack_compile_output)
+  end
+
+  def fetch(key)
+    data.fetch(key, defaults[key])
+  end
+
+  private
+    def data
+      @data ||= load
+    end
+
+    def load
+      config = begin
+        YAML.load_file(config_path.to_s, aliases: true)
+      rescue ArgumentError
+        YAML.load_file(config_path.to_s)
+      end
+      config[env].deep_symbolize_keys
+    rescue Errno::ENOENT => e
+      if self.class.installing
+        {}
+      else
+        raise "Webpacker configuration file not found #{config_path}. " \
+              "Please run rails webpacker:install " \
+              "Error: #{e.message}"
+      end
+    rescue Psych::SyntaxError => e
+      raise "YAML syntax error occurred while parsing #{config_path}. " \
+            "Please note that YAML must be consistently indented using spaces. Tabs are not allowed. " \
+            "Error: #{e.message}"
+    end
+
+    def defaults
+      @defaults ||= begin
+        path = File.expand_path("../../install/config/webpacker.yml", __FILE__)
+        config = begin
+          YAML.load_file(path, aliases: true)
+        rescue ArgumentError
+          YAML.load_file(path)
+        end
+        HashWithIndifferentAccess.new(config[env])
+      end
+    end
+end

data/lib/webpacker/dev_server.rb

@@ -0,0 +1,72 @@
+class Webpacker::DevServer
+  DEFAULT_ENV_PREFIX = "WEBPACKER_DEV_SERVER".freeze
+
+  # Configure dev server connection timeout (in seconds), default: 0.01
+  # Webpacker.dev_server.connect_timeout = 1
+  cattr_accessor(:connect_timeout) { 0.01 }
+
+  attr_reader :config
+
+  def initialize(config)
+    @config = config
+  end
+
+  def running?
+    if config.dev_server.present?
+      Socket.tcp(host, port, connect_timeout: connect_timeout).close
+      true
+    else
+      false
+    end
+  rescue
+    false
+  end
+
+  def host
+    fetch(:host)
+  end
+
+  def port
+    fetch(:port)
+  end
+
+  def https?
+    case fetch(:https)
+    when true, "true", Hash
+      true
+    else
+      false
+    end
+  end
+
+  def protocol
+    https? ? "https" : "http"
+  end
+
+  def host_with_port
+    "#{host}:#{port}"
+  end
+
+  def pretty?
+    fetch(:pretty)
+  end
+
+  def hmr?
+    fetch(:hmr)
+  end
+
+  def env_prefix
+    config.dev_server.fetch(:env_prefix, DEFAULT_ENV_PREFIX)
+  end
+
+  private
+    def fetch(key)
+      return nil unless config.dev_server.present?
+
+      ENV["#{env_prefix}_#{key.upcase}"] || config.dev_server.fetch(key, defaults[key])
+    end
+
+    def defaults
+      config.send(:defaults)[:dev_server] || {}
+    end
+end

data/lib/webpacker/dev_server_proxy.rb

@@ -0,0 +1,33 @@
+require "rack/proxy"
+
+class Webpacker::DevServerProxy < Rack::Proxy
+  delegate :config, :dev_server, to: :@webpacker
+
+  def initialize(app = nil, opts = {})
+    @webpacker = opts.delete(:webpacker) || Webpacker.instance
+    opts[:streaming] = false if Rails.env.test? && !opts.key?(:streaming)
+    super
+  end
+
+  def perform_request(env)
+    if env["PATH_INFO"].start_with?("/#{public_output_uri_path}") && dev_server.running?
+      env["HTTP_HOST"] = env["HTTP_X_FORWARDED_HOST"] = dev_server.host
+      env["HTTP_X_FORWARDED_SERVER"] = dev_server.host_with_port
+      env["HTTP_PORT"] = env["HTTP_X_FORWARDED_PORT"] = dev_server.port.to_s
+      env["HTTP_X_FORWARDED_PROTO"] = env["HTTP_X_FORWARDED_SCHEME"] = dev_server.protocol
+      unless dev_server.https?
+        env["HTTPS"] = env["HTTP_X_FORWARDED_SSL"] = "off"
+      end
+      env["SCRIPT_NAME"] = ""
+
+      super(env)
+    else
+      @app.call(env)
+    end
+  end
+
+  private
+    def public_output_uri_path
+      config.public_output_path.relative_path_from(config.public_path).to_s + "/"
+    end
+end

data/lib/webpacker/dev_server_runner.rb

@@ -0,0 +1,96 @@
+require "shellwords"
+require "socket"
+require "webpacker/configuration"
+require "webpacker/dev_server"
+require "webpacker/runner"
+
+module Webpacker
+  class DevServerRunner < Webpacker::Runner
+    def run
+      load_config
+      detect_unsupported_switches!
+      detect_port!
+      execute_cmd
+    end
+
+    private
+
+      def load_config
+        app_root = Pathname.new(@app_path)
+
+        @config = Configuration.new(
+          root_path: app_root,
+          config_path: Pathname.new(@webpacker_config),
+          env: ENV["RAILS_ENV"]
+        )
+
+        dev_server = DevServer.new(@config)
+
+        @hostname          = dev_server.host
+        @port              = dev_server.port
+        @pretty            = dev_server.pretty?
+        @https             = dev_server.https?
+        @hot               = dev_server.hmr?
+
+      rescue Errno::ENOENT, NoMethodError
+        $stdout.puts "webpack dev_server configuration not found in #{@config.config_path}[#{ENV["RAILS_ENV"]}]."
+        $stdout.puts "Please run bundle exec rails webpacker:install to install Webpacker"
+        exit!
+      end
+
+      UNSUPPORTED_SWITCHES = %w[--host --port]
+      private_constant :UNSUPPORTED_SWITCHES
+      def detect_unsupported_switches!
+        unsupported_switches = UNSUPPORTED_SWITCHES & @argv
+        if unsupported_switches.any?
+          $stdout.puts "The following CLI switches are not supported by Webpacker: #{unsupported_switches.join(' ')}. Please edit your command and try again."
+          exit!
+        end
+
+        if @argv.include?("--https") && !@https
+          $stdout.puts "Please set https: true in webpacker.yml to use the --https command line flag."
+          exit!
+        end
+      end
+
+      def detect_port!
+        server = TCPServer.new(@hostname, @port)
+        server.close
+
+      rescue Errno::EADDRINUSE
+        $stdout.puts "Another program is running on port #{@port}. Set a new port in #{@config.config_path} for dev_server"
+        exit!
+      end
+
+      def execute_cmd
+        env = Webpacker::Compiler.env
+        env["WEBPACKER_CONFIG"] = @webpacker_config
+        env["WEBPACK_SERVE"] = "true"
+
+        cmd = if node_modules_bin_exist?
+          ["#{@node_modules_bin_path}/webpack", "serve"]
+        else
+          ["yarn", "webpack", "serve"]
+        end
+
+        if @argv.include?("--debug-webpacker")
+          cmd = [ "node", "--inspect-brk", "--trace-warnings" ] + cmd
+          @argv.delete "--debug-webpacker"
+        end
+
+        cmd += ["--config", @webpack_config]
+        cmd += ["--progress", "--color"] if @pretty
+
+        cmd += ["--hot"] if @hot
+        cmd += @argv
+
+        Dir.chdir(@app_path) do
+          Kernel.exec env, *cmd
+        end
+      end
+
+      def node_modules_bin_exist?
+        File.exist?("#{@node_modules_bin_path}/webpack-dev-server")
+      end
+  end
+end

data/lib/webpacker/env.rb

@@ -0,0 +1,43 @@
+class Webpacker::Env
+  DEFAULT = "production".freeze
+
+  delegate :config_path, :logger, to: :@webpacker
+
+  def self.inquire(webpacker)
+    new(webpacker).inquire
+  end
+
+  def initialize(webpacker)
+    @webpacker = webpacker
+  end
+
+  def inquire
+    fallback_env_warning if config_path.exist? && !current
+    current || DEFAULT.inquiry
+  end
+
+  private
+    def current
+      Rails.env.presence_in(available_environments)
+    end
+
+    def fallback_env_warning
+      logger.info "RAILS_ENV=#{Rails.env} environment is not defined in config/webpacker.yml, falling back to #{DEFAULT} environment"
+    end
+
+    def available_environments
+      if config_path.exist?
+        begin
+          YAML.load_file(config_path.to_s, aliases: true)
+        rescue ArgumentError
+          YAML.load_file(config_path.to_s)
+        end
+      else
+        [].freeze
+      end
+    rescue Psych::SyntaxError => e
+      raise "YAML syntax error occurred while parsing #{config_path}. " \
+            "Please note that YAML must be consistently indented using spaces. Tabs are not allowed. " \
+            "Error: #{e.message}"
+    end
+end