webpacker 4.3.0 → 6.0.0.rc.6

data/lib/webpacker/compiler.rb

@@ -4,6 +4,8 @@ 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
@@ -20,21 +22,20 @@ class Webpacker::Compiler
     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, (at least with ts-loader), 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.
+        # 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.info "Everything's up-to-date. Nothing to do"
+      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?
-    watched_files_digest == last_compilation_digest
+    last_compilation_digest&.== watched_files_digest
   end
 
   # Returns true if the compiled packs are out of date with the underlying asset files.
@@ -51,9 +52,12 @@ class Webpacker::Compiler
     end
 
     def watched_files_digest
-      files = Dir[*default_watched_paths, *watched_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("/"))
+      warn "Webpacker::Compiler.watched_paths has been deprecated. Set additional_paths in webpacker.yml instead." unless watched_paths.empty?
+      Dir.chdir File.expand_path(config.root_path) do
+        files = Dir[*default_watched_paths, *watched_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
     end
 
     def record_compilation_digest
@@ -61,12 +65,18 @@ class Webpacker::Compiler
       compilation_digest_path.write(watched_files_digest)
     end
 
+    def optionalRubyRunner
+      bin_webpack_path = config.root_path.join("bin/webpack")
+      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,
-        "#{RbConfig.ruby} ./bin/webpack",
+        "#{optionalRubyRunner} ./bin/webpack",
         chdir: File.expand_path(config.root_path)
       )
 
@@ -87,8 +97,8 @@ class Webpacker::Compiler
 
     def default_watched_paths
       [
-        *config.resolved_paths_globbed,
-        config.source_path_globbed,
+        *config.additional_paths,
+        "#{config.source_path}/**/*",
         "yarn.lock", "package.json",
         "config/webpack/**/*"
       ].freeze
@@ -102,6 +112,7 @@ class Webpacker::Compiler
       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_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

@@ -23,16 +23,8 @@ class Webpacker::Configuration
     root_path.join(fetch(:source_path))
   end
 
-  def source_path_globbed
-    globbed_path_with_extensions(source_path.relative_path_from(root_path))
-  end
-
-  def resolved_paths
-    fetch(:resolved_paths)
-  end
-
-  def resolved_paths_globbed
-    resolved_paths.map { |p| globbed_path_with_extensions(p) }
+  def additional_paths
+    fetch(:additional_paths)
   end
 
   def source_entry_path
@@ -59,38 +51,34 @@ class Webpacker::Configuration
     root_path.join(fetch(:cache_path))
   end
 
-  def extensions
-    fetch(:extensions)
-  end
-
   def check_yarn_integrity=(value)
-    data[:check_yarn_integrity] = value
-  end
-
-  def check_yarn_integrity?
-    fetch(:check_yarn_integrity)
+    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 extract_css?
-    fetch(:extract_css)
+  def fetch(key)
+    data.fetch(key, defaults[key])
   end
 
   private
-    def fetch(key)
-      data.fetch(key, defaults[key])
-    end
-
     def data
       @data ||= load
     end
 
     def load
-      YAML.load(config_path.read)[env].deep_symbolize_keys
-
+      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
       raise "Webpacker configuration file not found #{config_path}. " \
             "Please run rails webpacker:install " \
@@ -103,11 +91,14 @@ class Webpacker::Configuration
     end
 
     def defaults
-      @defaults ||= \
-        HashWithIndifferentAccess.new(YAML.load_file(File.expand_path("../../install/config/webpacker.yml", __FILE__))[env])
-    end
-
-    def globbed_path_with_extensions(path)
-      "#{path}/**/*{#{extensions.join(',')}}"
+      @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

@@ -51,12 +51,18 @@ class Webpacker::DevServer
     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
 

data/lib/webpacker/dev_server_proxy.rb

@@ -11,7 +11,9 @@ class Webpacker::DevServerProxy < Rack::Proxy
 
   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"] = env["HTTP_X_FORWARDED_SERVER"] = dev_server.host_with_port
+      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"

data/lib/webpacker/dev_server_runner.rb

@@ -8,58 +8,82 @@ 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(
+        @config = Configuration.new(
           root_path: app_root,
-          config_path: app_root.join("config/webpacker.yml"),
+          config_path: Pathname.new(@webpacker_config),
           env: ENV["RAILS_ENV"]
         )
 
-        dev_server = DevServer.new(config)
+        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 "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_file} for dev_server"
+        $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-dev-server"]
+          ["#{@node_modules_bin_path}/webpack", "serve"]
         else
-          ["yarn", "webpack-dev-server"]
+          ["yarn", "webpack", "serve"]
         end
 
-        if ARGV.include?("--debug")
-          cmd = [ "node", "--inspect-brk"] + cmd
-          ARGV.delete("--debug")
+        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

data/lib/webpacker/env.rb

@@ -27,7 +27,11 @@ class Webpacker::Env
 
     def available_environments
       if config_path.exist?
-        YAML.load(config_path.read).keys
+        begin
+          YAML.load_file(config_path.to_s, aliases: true)
+        rescue ArgumentError
+          YAML.load_file(config_path.to_s)
+        end
       else
         [].freeze
       end

data/lib/webpacker/helper.rb

@@ -7,37 +7,40 @@ module Webpacker::Helper
   end
 
   # Computes the relative path for a given Webpacker asset.
-  # Returns the relative path using manifest.json and passes it to asset_path helper.
-  # This will use asset_path internally, so most of their behaviors will be the same.
+  # Returns the relative path using manifest.json and passes it to path_to_asset helper.
+  # This will use path_to_asset internally, so most of their behaviors will be the same.
   #
   # Example:
   #
-  #   # When extract_css is false in webpacker.yml and the file is a css:
-  #   <%= asset_pack_path 'calendar.css' %>  # => nil
-  #
-  #   # When extract_css is true in webpacker.yml or the file is not a css:
   #   <%= asset_pack_path 'calendar.css' %> # => "/packs/calendar-1016838bab065ae1e122.css"
   def asset_pack_path(name, **options)
-    if current_webpacker_instance.config.extract_css? || !stylesheet?(name)
-      asset_path(current_webpacker_instance.manifest.lookup!(name), options)
-    end
+    path_to_asset(current_webpacker_instance.manifest.lookup!(name), options)
   end
 
   # Computes the absolute path for a given Webpacker asset.
-  # Returns the absolute path using manifest.json and passes it to asset_url helper.
-  # This will use asset_url internally, so most of their behaviors will be the same.
+  # Returns the absolute path using manifest.json and passes it to url_to_asset helper.
+  # This will use url_to_asset internally, so most of their behaviors will be the same.
   #
   # Example:
   #
-  #   # When extract_css is false in webpacker.yml and the file is a css:
-  #   <%= asset_pack_url 'calendar.css' %> # => nil
-  #
-  #   # When extract_css is true in webpacker.yml or the file is not a css:
   #   <%= asset_pack_url 'calendar.css' %> # => "http://example.com/packs/calendar-1016838bab065ae1e122.css"
   def asset_pack_url(name, **options)
-    if current_webpacker_instance.config.extract_css? || !stylesheet?(name)
-      asset_url(current_webpacker_instance.manifest.lookup!(name), options)
-    end
+    url_to_asset(current_webpacker_instance.manifest.lookup!(name), options)
+  end
+
+  # Computes the relative path for a given Webpacker image with the same automated processing as image_pack_tag.
+  # Returns the relative path using manifest.json and passes it to path_to_asset helper.
+  # This will use path_to_asset internally, so most of their behaviors will be the same.
+  def image_pack_path(name, **options)
+    resolve_path_to_image(name, **options)
+  end
+
+  # Computes the absolute path for a given Webpacker image with the same automated
+  # processing as image_pack_tag. Returns the relative path using manifest.json
+  # and passes it to path_to_asset helper. This will use path_to_asset internally,
+  # so most of their behaviors will be the same.
+  def image_pack_url(name, **options)
+    resolve_path_to_image(name, **options.merge(protocol: :request))
   end
 
   # Creates an image tag that references the named pack file.
@@ -46,7 +49,16 @@ module Webpacker::Helper
   #
   #  <%= image_pack_tag 'application.png', size: '16x10', alt: 'Edit Entry' %>
   #  <img alt='Edit Entry' src='/packs/application-k344a6d59eef8632c9d1.png' width='16' height='10' />
+  #
+  #  <%= image_pack_tag 'picture.png', srcset: { 'picture-2x.png' => '2x' } %>
+  #  <img srcset= "/packs/picture-2x-7cca48e6cae66ec07b8e.png 2x" src="/packs/picture-c38deda30895059837cf.png" >
   def image_pack_tag(name, **options)
+    if options[:srcset] && !options[:srcset].is_a?(String)
+      options[:srcset] = options[:srcset].map do |src_name, size|
+        "#{resolve_path_to_image(src_name)} #{size}"
+      end.join(", ")
+    end
+
     image_tag(resolve_path_to_image(name), options)
   end
 
@@ -60,43 +72,37 @@ module Webpacker::Helper
     favicon_link_tag(resolve_path_to_image(name), options)
   end
 
-  # Creates a script tag that references the named pack file, as compiled by webpack per the entries list
-  # in config/webpack/shared.js. By default, this list is auto-generated to match everything in
-  # app/javascript/packs/*.js. In production mode, the digested reference is automatically looked up.
-  #
-  # Example:
-  #
-  #   <%= javascript_pack_tag 'calendar', 'data-turbolinks-track': 'reload' %> # =>
-  #   <script src="/packs/calendar-1016838bab065ae1e314.js" data-turbolinks-track="reload"></script>
-  def javascript_pack_tag(*names, **options)
-    javascript_include_tag(*sources_from_manifest_entries(names, type: :javascript), **options)
-  end
-
   # Creates script tags that reference the js chunks from entrypoints when using split chunks API,
-  # as compiled by webpack per the entries list in config/webpack/shared.js.
+  # as compiled by webpack per the entries list in package/environments/base.js.
   # By default, this list is auto-generated to match everything in
-  # app/javascript/packs/*.js and all the dependent chunks. In production mode, the digested reference is automatically looked up.
+  # app/packs/entrypoints/*.js and all the dependent chunks. In production mode, the digested reference is automatically looked up.
   # See: https://webpack.js.org/plugins/split-chunks-plugin/
+  #
   # Example:
   #
-  #   <%= javascript_packs_with_chunks_tag 'calendar', 'map', 'data-turbolinks-track': 'reload' %> # =>
-  #   <script src="/packs/vendor-16838bab065ae1e314.chunk.js" data-turbolinks-track="reload"></script>
-  #   <script src="/packs/calendar~runtime-16838bab065ae1e314.chunk.js" data-turbolinks-track="reload"></script>
-  #   <script src="/packs/calendar-1016838bab065ae1e314.chunk.js" data-turbolinks-track="reload"></script>
-  #   <script src="/packs/map~runtime-16838bab065ae1e314.chunk.js" data-turbolinks-track="reload"></script>
-  #   <script src="/packs/map-16838bab065ae1e314.chunk.js" data-turbolinks-track="reload"></script>
+  #   <%= javascript_pack_tag 'calendar', 'map', 'data-turbolinks-track': 'reload' %> # =>
+  #   <script src="/packs/vendor-16838bab065ae1e314.chunk.js" data-turbolinks-track="reload" defer="true"></script>
+  #   <script src="/packs/calendar~runtime-16838bab065ae1e314.chunk.js" data-turbolinks-track="reload" defer="true"></script>
+  #   <script src="/packs/calendar-1016838bab065ae1e314.chunk.js" data-turbolinks-track="reload" defer="true"></script>
+  #   <script src="/packs/map~runtime-16838bab065ae1e314.chunk.js" data-turbolinks-track="reload" defer="true"></script>
+  #   <script src="/packs/map-16838bab065ae1e314.chunk.js" data-turbolinks-track="reload" defer="true"></script>
+  #
   # DO:
-  # <%= javascript_packs_with_chunks_tag 'calendar', 'map' %>
+  #
+  #   <%= javascript_pack_tag 'calendar', 'map' %>
+  #
   # DON'T:
-  # <%= javascript_packs_with_chunks_tag 'calendar' %>
-  # <%= javascript_packs_with_chunks_tag 'map' %>
-  def javascript_packs_with_chunks_tag(*names, **options)
-    javascript_include_tag(*sources_from_manifest_entrypoints(names, type: :javascript), **options)
+  #
+  #   <%= javascript_pack_tag 'calendar' %>
+  #   <%= javascript_pack_tag 'map' %>
+  def javascript_pack_tag(*names, defer: true, **options)
+    javascript_include_tag(*sources_from_manifest_entrypoints(names, type: :javascript), **options.tap { |o| o[:defer] = defer })
   end
 
   # Creates a link tag, for preloading, that references a given Webpacker asset.
   # In production mode, the digested reference is automatically looked up.
   # See: https://developer.mozilla.org/en-US/docs/Web/HTML/Preloading_content
+  #
   # Example:
   #
   #   <%= preload_pack_asset 'fonts/fa-regular-400.woff2' %> # =>
@@ -109,68 +115,47 @@ module Webpacker::Helper
     end
   end
 
-  # Creates a link tag that references the named pack file, as compiled by webpack per the entries list
-  # in config/webpack/shared.js. By default, this list is auto-generated to match everything in
-  # app/javascript/packs/*.js. In production mode, the digested reference is automatically looked up.
-  #
-  # Note: If the development server is running and hot module replacement is active, this will return nothing.
-  # In that setup you need to configure your styles to be inlined in your JavaScript for hot reloading.
-  #
-  # Examples:
-  #
-  #   # When extract_css is false in webpacker.yml:
-  #   <%= stylesheet_pack_tag 'calendar', 'data-turbolinks-track': 'reload' %> # =>
-  #   nil
-  #
-  #   # When extract_css is true in webpacker.yml:
-  #   <%= stylesheet_pack_tag 'calendar', 'data-turbolinks-track': 'reload' %> # =>
-  #   <link rel="stylesheet" media="screen" href="/packs/calendar-1016838bab065ae1e122.css" data-turbolinks-track="reload" />
-  def stylesheet_pack_tag(*names, **options)
-    if current_webpacker_instance.config.extract_css?
-      stylesheet_link_tag(*sources_from_manifest_entries(names, type: :stylesheet), **options)
-    end
-  end
-
   # Creates link tags that reference the css chunks from entrypoints when using split chunks API,
-  # as compiled by webpack per the entries list in config/webpack/shared.js.
+  # as compiled by webpack per the entries list in package/environments/base.js.
   # By default, this list is auto-generated to match everything in
-  # app/javascript/packs/*.js and all the dependent chunks. In production mode, the digested reference is automatically looked up.
+  # app/packs/entrypoints/*.js and all the dependent chunks. In production mode, the digested reference is automatically looked up.
   # See: https://webpack.js.org/plugins/split-chunks-plugin/
   #
   # Examples:
   #
-  #   <%= stylesheet_packs_with_chunks_tag 'calendar', 'map' %> # =>
+  #   <%= stylesheet_pack_tag 'calendar', 'map' %> # =>
   #   <link rel="stylesheet" media="screen" href="/packs/3-8c7ce31a.chunk.css" />
   #   <link rel="stylesheet" media="screen" href="/packs/calendar-8c7ce31a.chunk.css" />
   #   <link rel="stylesheet" media="screen" href="/packs/map-8c7ce31a.chunk.css" />
+  #
+  #   When using the webpack-dev-server, CSS is inlined so HMR can be turned on for CSS,
+  #   including CSS modules
+  #   <%= stylesheet_pack_tag 'calendar', 'map' %> # => nil
+  #
   # DO:
-  # <%= stylesheet_packs_with_chunks_tag 'calendar', 'map' %>
+  #
+  #   <%= stylesheet_pack_tag 'calendar', 'map' %>
+  #
   # DON'T:
-  # <%= stylesheet_packs_with_chunks_tag 'calendar' %>
-  # <%= stylesheet_packs_with_chunks_tag 'map' %>
-  def stylesheet_packs_with_chunks_tag(*names, **options)
-    if current_webpacker_instance.config.extract_css?
-      stylesheet_link_tag(*sources_from_manifest_entrypoints(names, type: :stylesheet), **options)
-    end
+  #
+  #   <%= stylesheet_pack_tag 'calendar' %>
+  #   <%= stylesheet_pack_tag 'map' %>
+  def stylesheet_pack_tag(*names, **options)
+    return "" if Webpacker.inlining_css?
+
+    stylesheet_link_tag(*sources_from_manifest_entrypoints(names, type: :stylesheet), **options)
   end
 
   private
-    def stylesheet?(name)
-      File.extname(name) == ".css"
-    end
-
-    def sources_from_manifest_entries(names, type:)
-      names.map { |name| current_webpacker_instance.manifest.lookup!(name, type: type) }.flatten
-    end
 
     def sources_from_manifest_entrypoints(names, type:)
-      names.map { |name| current_webpacker_instance.manifest.lookup_pack_with_chunks!(name, type: type) }.flatten.uniq
+      names.map { |name| current_webpacker_instance.manifest.lookup_pack_with_chunks!(name.to_s, type: type) }.flatten.uniq
     end
 
-    def resolve_path_to_image(name)
-      path = name.starts_with?("media/images/") ? name : "media/images/#{name}"
-      asset_path(current_webpacker_instance.manifest.lookup!(path))
+    def resolve_path_to_image(name, **options)
+      path = name.starts_with?("static/") ? name : "static/#{name}"
+      path_to_asset(current_webpacker_instance.manifest.lookup!(path), options)
     rescue
-      asset_path(current_webpacker_instance.manifest.lookup!(name))
+      path_to_asset(current_webpacker_instance.manifest.lookup!(name), options)
     end
 end

data/lib/webpacker/instance.rb

@@ -34,4 +34,8 @@ class Webpacker::Instance
   def commands
     @commands ||= Webpacker::Commands.new self
   end
+
+  def inlining_css?
+    dev_server.hmr? && dev_server.running?
+  end
 end

data/lib/webpacker/manifest.rb

@@ -23,13 +23,13 @@ class Webpacker::Manifest
 
     manifest_pack_type = manifest_type(pack_type[:type])
     manifest_pack_name = manifest_name(name, manifest_pack_type)
-    find("entrypoints")[manifest_pack_name][manifest_pack_type]
+    find("entrypoints")[manifest_pack_name]["assets"][manifest_pack_type]
   rescue NoMethodError
     nil
   end
 
   def lookup_pack_with_chunks!(name, pack_type = {})
-    lookup_pack_with_chunks(name, pack_type) || handle_missing_entry(name)
+    lookup_pack_with_chunks(name, pack_type) || handle_missing_entry(name, pack_type)
   end
 
   # Computes the relative path for a given Webpacker asset using manifest.json.
@@ -46,7 +46,7 @@ class Webpacker::Manifest
 
   # Like lookup, except that if no asset is found, raises a Webpacker::Manifest::MissingEntryError.
   def lookup!(name, pack_type = {})
-    lookup(name, pack_type) || handle_missing_entry(name)
+    lookup(name, pack_type) || handle_missing_entry(name, pack_type)
   end
 
   private
@@ -75,8 +75,8 @@ class Webpacker::Manifest
       "#{name}.#{manifest_type(pack_type)}"
     end
 
-    def handle_missing_entry(name)
-      raise Webpacker::Manifest::MissingEntryError, missing_file_from_manifest_error(name)
+    def handle_missing_entry(name, pack_type)
+      raise Webpacker::Manifest::MissingEntryError, missing_file_from_manifest_error(full_pack_name(name, pack_type[:type]))
     end
 
     def load
@@ -91,8 +91,7 @@ class Webpacker::Manifest
     # manifest hash the entrypoints are defined by their pack name without the extension.
     # When the user provides a name with a file extension, we want to try to strip it off.
     def manifest_name(name, pack_type)
-      return name if File.extname(name.to_s).empty?
-      File.basename(name, pack_type)
+      name.chomp(".#{pack_type}")
     end
 
     def manifest_type(pack_type)