shakapacker 6.6.0 → 7.0.0.rc.0

data/lib/{webpacker → shakapacker}/configuration.rb

@@ -2,7 +2,7 @@ require "yaml"
 require "active_support/core_ext/hash/keys"
 require "active_support/core_ext/hash/indifferent_access"
 
-class Webpacker::Configuration
+class Shakapacker::Configuration
   class << self
     attr_accessor :installing
   end
@@ -11,8 +11,11 @@ class Webpacker::Configuration
 
   def initialize(root_path:, config_path:, env:)
     @root_path = root_path
-    @config_path = config_path
     @env = env
+
+    # For backward compatibility
+    Shakapacker.set_shakapacker_env_variables_for_backward_compatibility
+    @config_path = Pathname.new(ENV["SHAKAPACKER_CONFIG"] || config_path)
   end
 
   def dev_server
@@ -31,13 +34,24 @@ class Webpacker::Configuration
     fetch(:ensure_consistent_versioning)
   end
 
-  def webpacker_precompile?
+  def shakapacker_precompile?
     # ENV of false takes precedence
-    return false if %w(no false n f).include?(ENV["WEBPACKER_PRECOMPILE"])
-    return true if %w(yes true y t).include?(ENV["WEBPACKER_PRECOMPILE"])
+    return false if %w(no false n f).include?(ENV["SHAKAPACKER_PRECOMPILE"])
+    return true if %w(yes true y t).include?(ENV["SHAKAPACKER_PRECOMPILE"])
 
     return false unless config_path.exist?
-    fetch(:webpacker_precompile)
+    fetch(:shakapacker_precompile)
+  end
+
+  def webpacker_precompile?
+    Shakapacker.puts_deprecation_message(
+      Shakapacker.short_deprecation_message(
+        "webpacker_precompile?",
+        "shakapacker_precompile?"
+      )
+    )
+
+    shakapacker_precompile?
   end
 
   def source_path
@@ -49,7 +63,7 @@ class Webpacker::Configuration
   end
 
   def source_entry_path
-    source_path.join(fetch(:source_entry_path))
+    source_path.join(relative_path(fetch(:source_entry_path)))
   end
 
   def manifest_path
@@ -80,14 +94,6 @@ class Webpacker::Configuration
     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
@@ -97,7 +103,17 @@ class Webpacker::Configuration
   end
 
   def fetch(key)
-    data.fetch(key, defaults[key])
+    return data.fetch(key, defaults[key]) unless key == :webpacker_precompile
+
+    # for backward compatibility
+    Shakapacker.puts_deprecation_message(
+      Shakapacker.short_deprecation_message(
+        "webpacker_precompile",
+        "shakapacker_precompile"
+      )
+    )
+
+    data.fetch(key, defaults[:shakapacker_precompile])
   end
 
   private
@@ -111,13 +127,22 @@ class Webpacker::Configuration
       rescue ArgumentError
         YAML.load_file(config_path.to_s)
       end
-      config[env].deep_symbolize_keys
+      symbolized_config = config[env].deep_symbolize_keys
+
+      # For backward compatibility
+      if symbolized_config.key?(:shakapacker_precompile) && !symbolized_config.key?(:webpacker_precompile)
+        symbolized_config[:webpacker_precompile] = symbolized_config[:shakapacker_precompile]
+      elsif !symbolized_config.key?(:shakapacker_precompile) && symbolized_config.key?(:webpacker_precompile)
+        symbolized_config[:shakapacker_precompile] = symbolized_config[:webpacker_precompile]
+      end
+
+      return symbolized_config
     rescue Errno::ENOENT => e
       if self.class.installing
         {}
       else
-        raise "Webpacker configuration file not found #{config_path}. " \
-              "Please run rails webpacker:install " \
+        raise "Shakapacker configuration file not found #{config_path}. " \
+              "Please run rails shakapacker:install " \
               "Error: #{e.message}"
       end
     rescue Psych::SyntaxError => e
@@ -128,13 +153,19 @@ class Webpacker::Configuration
 
     def defaults
       @defaults ||= begin
-        path = File.expand_path("../../install/config/webpacker.yml", __FILE__)
+        path = File.expand_path("../../install/config/shakapacker.yml", __FILE__)
         config = begin
           YAML.load_file(path, aliases: true)
         rescue ArgumentError
           YAML.load_file(path)
         end
-        HashWithIndifferentAccess.new(config[env] || config[Webpacker::DEFAULT_ENV])
+        HashWithIndifferentAccess.new(config[env] || config[Shakapacker::DEFAULT_ENV])
       end
     end
+
+    def relative_path(path)
+      return ".#{path}" if path.start_with?("/")
+
+      path
+    end
 end

data/lib/shakapacker/deprecation_helper.rb

@@ -0,0 +1,88 @@
+module Shakapacker
+  DEPRECATION_GUIDE_URL = "https://github.com/shakacode/shakapacker/docs/v7_upgrade.md"
+  DEPRECATION_MESSAGE = <<~MSG
+    DEPRECATION NOTICE:
+
+    Using webpacker spelling is deprecated in Shakapacker.
+    Update your project with the new spelling.
+
+    For more information about this process, check:
+    #{DEPRECATION_GUIDE_URL}
+  MSG
+
+  def get_config_file_path_with_backward_compatibility(config_path)
+    if config_path.to_s.end_with?("shakapacker.yml") && !File.exist?(config_path)
+      webpacker_config_path = if config_path.class == Pathname
+        Pathname.new(config_path.to_s.gsub("shakapacker.yml", "webpacker.yml"))
+      else
+        config_path.gsub("shakapacker.yml", "webpacker.yml")
+      end
+
+      if File.exist?(webpacker_config_path)
+        puts_deprecation_message(
+          short_deprecation_message(
+            "config/webpacker.yml",
+            "config/shakapacker.yml"
+          )
+        )
+        return webpacker_config_path
+      end
+    end
+
+    config_path
+  end
+
+  def set_shakapacker_env_variables_for_backward_compatibility
+    webpacker_env_variables = ENV.select { |key| key.start_with?("WEBPACKER_") }
+
+    deprecation_message_body = ""
+
+    webpacker_env_variables.each do |webpacker_key, _|
+      shakapacker_key = webpacker_key.gsub("WEBPACKER_", "SHAKAPACKER_")
+      next if ENV.key?(shakapacker_key)
+
+      deprecation_message_body += <<~MSG
+        Use `#{shakapacker_key}` instead of the deprecated `#{webpacker_key}`.
+      MSG
+
+      ENV[shakapacker_key] = ENV[webpacker_key]
+    end
+
+    if deprecation_message_body.present?
+      Shakapacker.puts_deprecation_message(
+        <<~MSG
+          DEPRECATION NOTICE:
+
+          #{deprecation_message_body}
+          Read more: #{Shakapacker::DEPRECATION_GUIDE_URL}
+        MSG
+      )
+    end
+  end
+
+  def short_deprecation_message(old_usage, new_usage)
+    <<~MSG
+      DEPRECATION NOTICE:
+
+      Consider using `#{new_usage}` instead of the deprecated `#{old_usage}`.
+      Read more: #{DEPRECATION_GUIDE_URL}
+    MSG
+  end
+
+  def puts_deprecation_message(message)
+    puts <<~MSG
+      \e[33m
+      #{message}
+      \e[0m
+    MSG
+  end
+
+  def puts_rake_deprecation_message(webpacker_task_name)
+    Shakapacker.puts_deprecation_message(
+      Shakapacker.short_deprecation_message(
+        "rake #{webpacker_task_name}",
+        "rake #{webpacker_task_name.gsub("webpacker", "shakapacker")}"
+      )
+    )
+  end
+end

data/lib/{webpacker → shakapacker}/dev_server.rb

@@ -1,8 +1,8 @@
-class Webpacker::DevServer
-  DEFAULT_ENV_PREFIX = "WEBPACKER_DEV_SERVER".freeze
+class Shakapacker::DevServer
+  DEFAULT_ENV_PREFIX = "SHAKAPACKER_DEV_SERVER".freeze
 
   # Configure dev server connection timeout (in seconds), default: 0.1
-  # Webpacker.dev_server.connect_timeout = 1
+  # Shakapacker.dev_server.connect_timeout = 1
   cattr_accessor(:connect_timeout) { 0.1 }
 
   attr_reader :config
@@ -39,8 +39,29 @@ class Webpacker::DevServer
     end
   end
 
+  def server
+    server_value = fetch(:server)
+    server_type = server_value.is_a?(Hash) ? server_value[:type] : server_value
+
+    return server_type if ["http", "https"].include?(server_type)
+
+    return "http" if server_type.nil?
+
+    puts <<~MSG
+    WARNING:
+    `server: #{server_type}` is not a valid configuration in Shakapacker.
+    Falling back to default `server: http`.
+    MSG
+
+    "http"
+  rescue KeyError
+    "http"
+  end
+
   def protocol
-    https? ? "https" : "http"
+    return "https" if server == "https" || https? == true
+
+    "http"
   end
 
   def host_with_port
@@ -73,6 +94,8 @@ class Webpacker::DevServer
       return nil unless config.dev_server.present?
 
       ENV["#{env_prefix}_#{key.upcase}"] || config.dev_server.fetch(key, defaults[key])
+    rescue
+      nil
     end
 
     def defaults

data/lib/{webpacker → shakapacker}/dev_server_proxy.rb

@@ -1,10 +1,10 @@
 require "rack/proxy"
 
-class Webpacker::DevServerProxy < Rack::Proxy
-  delegate :config, :dev_server, to: :@webpacker
+class Shakapacker::DevServerProxy < Rack::Proxy
+  delegate :config, :dev_server, to: :@instance
 
   def initialize(app = nil, opts = {})
-    @webpacker = opts.delete(:webpacker) || Webpacker.instance
+    @instance = opts.delete(:shakapacker) || Shakapacker.instance
     opts[:streaming] = false if Rails.env.test? && !opts.key?(:streaming)
     super
   end
@@ -15,7 +15,7 @@ class Webpacker::DevServerProxy < Rack::Proxy
       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?
+      unless dev_server.protocol == "https"
         env["HTTPS"] = env["HTTP_X_FORWARDED_SSL"] = "off"
       end
       env["SCRIPT_NAME"] = ""

data/lib/shakapacker/dev_server_runner.rb

@@ -0,0 +1,104 @@
+require "shellwords"
+require "socket"
+require "shakapacker/configuration"
+require "shakapacker/dev_server"
+require "shakapacker/runner"
+
+module Shakapacker
+  class DevServerRunner < Shakapacker::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(@shakapacker_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.protocol == "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 shakapacker:install to install Shakapacker"
+        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 Shakapacker: #{unsupported_switches.join(' ')}. Please edit your command and try again."
+          exit!
+        end
+
+        if @argv.include?("--https") && !@https
+          $stdout.puts "Please set https: true in shakapacker.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 = Shakapacker::Compiler.env
+        env["SHAKAPACKER_CONFIG"] = @shakapacker_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")
+          Shakapacker.puts_deprecation_message(
+            Shakapacker.short_deprecation_message(
+              "--debug-webpacker",
+              "--debug-shakapacker"
+            )
+          )
+        end
+
+        if @argv.delete("--debug-shakapacker") || @argv.delete("--debug-webpacker")
+          cmd = [ "node", "--inspect-brk", "--trace-warnings" ] + cmd
+        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 → shakapacker}/digest_strategy.rb

@@ -1,7 +1,7 @@
 require "digest/sha1"
-require "webpacker/base_strategy"
+require "shakapacker/base_strategy"
 
-module Webpacker
+module Shakapacker
   class DigestStrategy < BaseStrategy
     # Returns true if all the compiled packs are up to date with the underlying asset files.
     def fresh?
@@ -31,10 +31,10 @@ module Webpacker
       def watched_files_digest
         if Rails.env.development?
           warn <<~MSG.strip
-          Webpacker::Compiler - Slow setup for development
+          Shakapacker::Compiler - Slow setup for development
           Prepare JS assets with either:
-          1. Running `bin/webpacker-dev-server`
-          2. Set `compile` to false in webpacker.yml and run `bin/webpacker -w`
+          1. Running `bin/shakapacker-dev-server`
+          2. Set `compile` to false in shakapacker.yml and run `bin/shakapacker -w`
         MSG
         end
 
@@ -53,7 +53,7 @@ module Webpacker
       end
 
       def compilation_digest_path
-        config.cache_path.join("last-compilation-digest-#{Webpacker.env}")
+        config.cache_path.join("last-compilation-digest-#{Shakapacker.env}")
       end
   end
 end

data/lib/{webpacker → shakapacker}/env.rb

@@ -1,17 +1,17 @@
-class Webpacker::Env
-  delegate :config_path, :logger, to: :@webpacker
+class Shakapacker::Env
+  delegate :config_path, :logger, to: :@instance
 
-  def self.inquire(webpacker)
-    new(webpacker).inquire
+  def self.inquire(instance)
+    new(instance).inquire
   end
 
-  def initialize(webpacker)
-    @webpacker = webpacker
+  def initialize(instance)
+    @instance = instance
   end
 
   def inquire
     fallback_env_warning if config_path.exist? && !current
-    current || Webpacker::DEFAULT_ENV.inquiry
+    current || Shakapacker::DEFAULT_ENV.inquiry
   end
 
   private
@@ -20,7 +20,7 @@ class Webpacker::Env
     end
 
     def fallback_env_warning
-      logger.info "RAILS_ENV=#{Rails.env} environment is not defined in config/webpacker.yml, falling back to #{Webpacker::DEFAULT_ENV} environment"
+      logger.info "RAILS_ENV=#{Rails.env} environment is not defined in config/shakapacker.yml, falling back to #{Shakapacker::DEFAULT_ENV} environment"
     end
 
     def available_environments

data/lib/{webpacker → shakapacker}/helper.rb

@@ -1,12 +1,12 @@
-module Webpacker::Helper
-  # Returns the current Webpacker instance.
-  # Could be overridden to use multiple Webpacker
+module Shakapacker::Helper
+  # Returns the current Shakapacker instance.
+  # Could be overridden to use multiple Shakapacker
   # configurations within the same app (e.g. with engines).
-  def current_webpacker_instance
-    Webpacker.instance
+  def current_shakapacker_instance
+    Shakapacker.instance
   end
 
-  # Computes the relative path for a given Webpacker asset.
+  # Computes the relative path for a given Shakapacker asset.
   # 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.
   #
@@ -14,10 +14,10 @@ module Webpacker::Helper
   #
   #   <%= asset_pack_path 'calendar.css' %> # => "/packs/calendar-1016838bab065ae1e122.css"
   def asset_pack_path(name, **options)
-    path_to_asset(current_webpacker_instance.manifest.lookup!(name), options)
+    path_to_asset(current_shakapacker_instance.manifest.lookup!(name), options)
   end
 
-  # Computes the absolute path for a given Webpacker asset.
+  # Computes the absolute path for a given Shakapacker asset.
   # 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.
   #
@@ -25,17 +25,17 @@ module Webpacker::Helper
   #
   #   <%= asset_pack_url 'calendar.css' %> # => "http://example.com/packs/calendar-1016838bab065ae1e122.css"
   def asset_pack_url(name, **options)
-    url_to_asset(current_webpacker_instance.manifest.lookup!(name), options)
+    url_to_asset(current_shakapacker_instance.manifest.lookup!(name), options)
   end
 
-  # Computes the relative path for a given Webpacker image with the same automated processing as image_pack_tag.
+  # Computes the relative path for a given Shakapacker 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
+  # Computes the absolute path for a given Shakapacker 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.
@@ -75,7 +75,7 @@ module Webpacker::Helper
   # Creates script tags that reference the js chunks from entrypoints when using split chunks API,
   # 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/packs/entrypoints/*.js and all the dependent chunks. In production mode, the digested reference is automatically looked up.
+  # app/javascript/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:
@@ -114,7 +114,7 @@ module Webpacker::Helper
     end
   end
 
-  # Creates a link tag, for preloading, that references a given Webpacker asset.
+  # Creates a link tag, for preloading, that references a given Shakapacker asset.
   # In production mode, the digested reference is automatically looked up.
   # See: https://developer.mozilla.org/en-US/docs/Web/HTML/Preloading_content
   #
@@ -124,7 +124,7 @@ module Webpacker::Helper
   #   <link rel="preload" href="/packs/fonts/fa-regular-400-944fb546bd7018b07190a32244f67dc9.woff2" as="font" type="font/woff2" crossorigin="anonymous">
   def preload_pack_asset(name, **options)
     if self.class.method_defined?(:preload_link_tag)
-      preload_link_tag(current_webpacker_instance.manifest.lookup!(name), options)
+      preload_link_tag(current_shakapacker_instance.manifest.lookup!(name), options)
     else
       raise "You need Rails >= 5.2 to use this tag."
     end
@@ -133,7 +133,7 @@ module Webpacker::Helper
   # Creates link tags that reference the css chunks from entrypoints when using split chunks API,
   # 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/packs/entrypoints/*.js and all the dependent chunks. In production mode, the digested reference is automatically looked up.
+  # app/javascript/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:
@@ -156,7 +156,7 @@ module Webpacker::Helper
   #   <%= stylesheet_pack_tag 'calendar' %>
   #   <%= stylesheet_pack_tag 'map' %>
   def stylesheet_pack_tag(*names, **options)
-    return "" if Webpacker.inlining_css?
+    return "" if Shakapacker.inlining_css?
 
     requested_packs = sources_from_manifest_entrypoints(names, type: :stylesheet)
     appended_packs = available_sources_from_manifest_entrypoints(@stylesheet_pack_tag_queue || [], type: :stylesheet)
@@ -213,17 +213,17 @@ module Webpacker::Helper
     end
 
     def sources_from_manifest_entrypoints(names, type:)
-      names.map { |name| current_webpacker_instance.manifest.lookup_pack_with_chunks!(name.to_s, type: type) }.flatten.uniq
+      names.map { |name| current_shakapacker_instance.manifest.lookup_pack_with_chunks!(name.to_s, type: type) }.flatten.uniq
     end
 
     def available_sources_from_manifest_entrypoints(names, type:)
-      names.map { |name| current_webpacker_instance.manifest.lookup_pack_with_chunks(name.to_s, type: type) }.flatten.compact.uniq
+      names.map { |name| current_shakapacker_instance.manifest.lookup_pack_with_chunks(name.to_s, type: type) }.flatten.compact.uniq
     end
 
     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)
+      path_to_asset(current_shakapacker_instance.manifest.lookup!(path), options)
     rescue
-      path_to_asset(current_webpacker_instance.manifest.lookup!(name), options)
+      path_to_asset(current_shakapacker_instance.manifest.lookup!(name), options)
     end
 end

data/lib/{webpacker → shakapacker}/instance.rb

@@ -1,20 +1,23 @@
 require "pathname"
-class Webpacker::Instance
+
+class Shakapacker::Instance
   cattr_accessor(:logger) { ActiveSupport::TaggedLogging.new(ActiveSupport::Logger.new(STDOUT)) }
 
   attr_reader :root_path, :config_path
 
-  def initialize(root_path: Rails.root, config_path: Rails.root.join("config/webpacker.yml"))
+  def initialize(root_path: Rails.root, config_path: Rails.root.join("config/shakapacker.yml"))
     @root_path = root_path
-    @config_path = Pathname.new(ENV["WEBPACKER_CONFIG"] || config_path)
+
+    # For backward compatibility
+    @config_path = Shakapacker.get_config_file_path_with_backward_compatibility(config_path)
   end
 
   def env
-    @env ||= Webpacker::Env.inquire self
+    @env ||= Shakapacker::Env.inquire self
   end
 
   def config
-    @config ||= Webpacker::Configuration.new(
+    @config ||= Shakapacker::Configuration.new(
       root_path: root_path,
       config_path: config_path,
       env: env
@@ -22,23 +25,23 @@ class Webpacker::Instance
   end
 
   def strategy
-    @strategy ||= Webpacker::CompilerStrategy.from_config
+    @strategy ||= Shakapacker::CompilerStrategy.from_config
   end
 
   def compiler
-    @compiler ||= Webpacker::Compiler.new self
+    @compiler ||= Shakapacker::Compiler.new self
   end
 
   def dev_server
-    @dev_server ||= Webpacker::DevServer.new config
+    @dev_server ||= Shakapacker::DevServer.new config
   end
 
   def manifest
-    @manifest ||= Webpacker::Manifest.new self
+    @manifest ||= Shakapacker::Manifest.new self
   end
 
   def commands
-    @commands ||= Webpacker::Commands.new self
+    @commands ||= Shakapacker::Commands.new self
   end
 
   def inlining_css?