shakapacker 6.6.0 → 7.0.0.rc.1

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

@@ -1,16 +1,17 @@
 require "open3"
-require "webpacker/compiler_strategy"
+require "shakapacker/compiler_strategy"
+require "fileutils"
 
-class Webpacker::Compiler
+class Shakapacker::Compiler
   # Additional environment variables that the compiler is being run with
-  # Webpacker::Compiler.env['FRONTEND_API_KEY'] = 'your_secret_key'
+  # Shakapacker::Compiler.env['FRONTEND_API_KEY'] = 'your_secret_key'
   cattr_accessor(:env) { {} }
 
-  delegate :config, :logger, :strategy, to: :webpacker
+  delegate :config, :logger, :strategy, to: :instance
   delegate :fresh?, :stale?, :after_compile_hook, to: :strategy
 
-  def initialize(webpacker)
-    @webpacker = webpacker
+  def initialize(instance)
+    @instance = instance
   end
 
   def compile
@@ -32,7 +33,7 @@ class Webpacker::Compiler
   end
 
   private
-    attr_reader :webpacker
+    attr_reader :instance
 
     def acquire_ipc_lock
       open_lock_file do |lf|
@@ -55,15 +56,24 @@ class Webpacker::Compiler
     end
 
     def open_lock_file
-      lock_file_name = File.join(Dir.tmpdir, "shakapacker.lock")
-      File.open(lock_file_name, File::CREAT) do |lf|
+      create_lock_file_dir unless File.exist?(lock_file_path)
+
+      File.open(lock_file_path, File::CREAT) do |lf|
         return yield lf
       end
     end
 
+    def create_lock_file_dir
+      dirname = File.dirname(lock_file_path)
+      FileUtils.mkdir_p(dirname)
+    end
+
+    def lock_file_path
+      config.root_path.join("tmp/shakapacker.lock")
+    end
+
     def optionalRubyRunner
-      bin_webpack_path = config.root_path.join("bin/webpacker")
-      first_line = File.readlines(bin_webpack_path).first.chomp
+      first_line = File.readlines(bin_shakapacker_path).first.chomp
       /ruby/.match?(first_line) ? RbConfig.ruby : ""
     end
 
@@ -72,7 +82,7 @@ class Webpacker::Compiler
 
       stdout, stderr, status = Open3.capture3(
         webpack_env,
-        "#{optionalRubyRunner} ./bin/webpacker",
+        "#{optionalRubyRunner} #{bin_shakapacker_path}",
         chdir: File.expand_path(config.root_path)
       )
 
@@ -94,8 +104,26 @@ class Webpacker::Compiler
     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)
+      Shakapacker.set_shakapacker_env_variables_for_backward_compatibility
+
+      env.merge("SHAKAPACKER_ASSET_HOST"        => ENV.fetch("SHAKAPACKER_ASSET_HOST", ActionController::Base.helpers.compute_asset_host),
+                "SHAKAPACKER_RELATIVE_URL_ROOT" => ENV.fetch("SHAKAPACKER_RELATIVE_URL_ROOT", ActionController::Base.relative_url_root),
+                "SHAKAPACKER_CONFIG" => instance.config_path.to_s)
+    end
+
+    def bin_shakapacker_path
+      if File.exist?(config.root_path.join("bin/shakapacker"))
+        config.root_path.join("bin/shakapacker")
+      elsif File.exist?(config.root_path.join("bin/webpacker"))
+        Shakapacker.puts_deprecation_message(
+          Shakapacker.short_deprecation_message(
+            "bin/webpacker",
+            "bin/shakapacker"
+          )
+        )
+        config.root_path.join("bin/webpacker")
+      else
+        config.root_path.join("bin/shakapacker")
+      end
     end
 end

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

@@ -1,16 +1,16 @@
-require "webpacker/mtime_strategy"
-require "webpacker/digest_strategy"
+require "shakapacker/mtime_strategy"
+require "shakapacker/digest_strategy"
 
-module Webpacker
+module Shakapacker
   class CompilerStrategy
     def self.from_config
-      strategy_from_config = Webpacker.config.compiler_strategy
+      strategy_from_config = Shakapacker.config.compiler_strategy
 
       case strategy_from_config
       when "mtime"
-        Webpacker::MtimeStrategy.new
+        Shakapacker::MtimeStrategy.new
       when "digest"
-        Webpacker::DigestStrategy.new
+        Shakapacker::DigestStrategy.new
       else
         raise "Unknown strategy '#{strategy_from_config}'. " \
               "Available options are 'mtime' and 'digest'."

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,87 @@
+require "thor"
+
+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
+  SHELL = Thor::Shell::Color.new
+
+  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)
+    SHELL.say "\n#{message}\n", :yellow
+  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