jetpacker 0.1.0 → 0.2.0

data/lib/tasks/webpacker/binstubs.rake

@@ -0,0 +1,11 @@
+binstubs_template_path = File.expand_path("../../install/binstubs.rb", __dir__).freeze
+
+namespace :webpacker do
+  desc "Installs Webpacker binstubs in this application"
+  task binstubs: [:check_node, :check_yarn] do
+    require "rails/generators"
+    require "rails/generators/rails/app/app_generator"
+    generator = Rails::Generators::AppGenerator.new [Jets.root], {force: ENV['FORCE']}, destination_root: Jets.root
+    generator.apply binstubs_template_path, verbose: false
+  end
+end

data/lib/tasks/webpacker/check_binstubs.rake

@@ -0,0 +1,12 @@
+namespace :webpacker do
+  desc "Verifies that webpack & webpack-dev-server are present."
+  task :check_binstubs do
+    unless File.exist?("bin/webpack")
+      $stderr.puts "webpack binstubs not found.\n"\
+           "Have you run rails webpacker:install ?\n"\
+           "Make sure the bin directory or binstubs are not included in .gitignore\n"\
+           "Exiting!"
+      exit!
+    end
+  end
+end

data/lib/tasks/webpacker/check_node.rake

@@ -0,0 +1,24 @@
+namespace :webpacker do
+  desc "Verifies if Node.js is installed"
+  task :check_node do
+    begin
+      node_version = `node -v || nodejs -v`
+      raise Errno::ENOENT if node_version.blank?
+
+      pkg_path = Pathname.new("#{__dir__}/../../../package.json").realpath
+      node_requirement = JSON.parse(pkg_path.read)["engines"]["node"]
+
+      requirement = Gem::Requirement.new(node_requirement)
+      version = Gem::Version.new(node_version.strip.tr("v", ""))
+
+      unless requirement.satisfied_by?(version)
+        $stderr.puts "Webpacker requires Node.js #{requirement} and you are using #{version}"
+        $stderr.puts "Please upgrade Node.js https://nodejs.org/en/download/"
+        $stderr.puts "Exiting!" && exit!
+      end
+    rescue Errno::ENOENT
+      $stderr.puts "Node.js not installed. Please download and install Node.js https://nodejs.org/en/download/"
+      $stderr.puts "Exiting!" && exit!
+    end
+  end
+end

data/lib/tasks/webpacker/check_yarn.rake

@@ -0,0 +1,24 @@
+namespace :webpacker do
+  desc "Verifies if Yarn is installed"
+  task :check_yarn do
+    begin
+      yarn_version = `yarn --version`
+      raise Errno::ENOENT if yarn_version.blank?
+
+      pkg_path = Pathname.new("#{__dir__}/../../../package.json").realpath
+      yarn_requirement = JSON.parse(pkg_path.read)["engines"]["yarn"]
+
+      requirement = Gem::Requirement.new(yarn_requirement)
+      version = Gem::Version.new(yarn_version)
+
+      unless requirement.satisfied_by?(version)
+        $stderr.puts "Webpacker requires Yarn #{requirement} and you are using #{version}"
+        $stderr.puts "Please upgrade Yarn https://yarnpkg.com/lang/en/docs/install/"
+        $stderr.puts "Exiting!" && exit!
+      end
+    rescue Errno::ENOENT
+      $stderr.puts "Yarn not installed. Please download and install Yarn from https://yarnpkg.com/lang/en/docs/install/"
+      $stderr.puts "Exiting!" && exit!
+    end
+  end
+end

data/lib/tasks/webpacker/clean.rake

@@ -0,0 +1,21 @@
+$stdout.sync = true
+
+require "webpacker/configuration"
+
+namespace :webpacker do
+  desc "Remove old compiled webpacks"
+  task :clean, [:keep] => ["webpacker:verify_install", :environment] do |_, args|
+    Webpacker.ensure_log_goes_to_stdout do
+      Webpacker.clean(Integer(args.keep || 2))
+    end
+  end
+end
+
+# Run clean if the assets:clean is run
+if Rake::Task.task_defined?("assets:clean")
+  Rake::Task["assets:clean"].enhance do
+    Rake::Task["webpacker:clean"].invoke
+  end
+else
+  Rake::Task.define_task("assets:clean" => "webpacker:clean")
+end

data/lib/tasks/webpacker/clobber.rake

@@ -0,0 +1,16 @@
+require "webpacker/configuration"
+
+namespace :webpacker do
+  desc "Remove the webpack compiled output directory"
+  task clobber: ["webpacker:verify_install", :environment] do
+    Webpacker.clobber
+    $stdout.puts "Removed webpack output path directory #{Webpacker.config.public_output_path}"
+  end
+end
+
+# Run clobber if the assets:clobber is run
+if Rake::Task.task_defined?("assets:clobber")
+  Rake::Task["assets:clobber"].enhance do
+    Rake::Task["webpacker:clobber"].invoke
+  end
+end

data/lib/tasks/webpacker/compile.rake

@@ -0,0 +1,43 @@
+$stdout.sync = true
+
+def yarn_install_available?
+  rails_major = Rails::VERSION::MAJOR
+  rails_minor = Rails::VERSION::MINOR
+
+  rails_major > 5 || (rails_major == 5 && rails_minor >= 1)
+end
+
+def enhance_assets_precompile
+  # yarn:install was added in Rails 5.1
+  deps = yarn_install_available? ? [] : ["webpacker:yarn_install"]
+  Rake::Task["assets:precompile"].enhance(deps) do
+    Rake::Task["webpacker:compile"].invoke
+  end
+end
+
+namespace :webpacker do
+  desc "Compile JavaScript packs using webpack for production with digests"
+  task compile: ["webpacker:verify_install", :environment] do
+    Webpacker.with_node_env(ENV.fetch("NODE_ENV", "production")) do
+      Webpacker.ensure_log_goes_to_stdout do
+        if Webpacker.compile
+          # Successful compilation!
+        else
+          # Failed compilation
+          exit!
+        end
+      end
+    end
+  end
+end
+
+# Compile packs after we've compiled all other assets during precompilation
+skip_webpacker_precompile = %w(no false n f).include?(ENV["WEBPACKER_PRECOMPILE"])
+
+unless skip_webpacker_precompile
+  if Rake::Task.task_defined?("assets:precompile")
+    enhance_assets_precompile
+  else
+    Rake::Task.define_task("assets:precompile" => ["webpacker:yarn_install", "webpacker:compile"])
+  end
+end

data/lib/tasks/webpacker/info.rake

@@ -0,0 +1,20 @@
+require "webpacker/version"
+
+namespace :webpacker do
+  desc "Provide information on Webpacker's environment"
+  task :info do
+    $stdout.puts "Ruby: #{`ruby --version`}"
+    $stdout.puts "Jets: #{Jets.version}"
+    $stdout.puts "Rails: #{Rails.version}"
+    $stdout.puts "Webpacker: #{Webpacker::VERSION}"
+    $stdout.puts "Node: #{`node --version`}"
+    $stdout.puts "Yarn: #{`yarn --version`}"
+
+    $stdout.puts "\n"
+    $stdout.puts "@rails/webpacker: \n#{`npm list @rails/webpacker version`}"
+
+    $stdout.puts "Is bin/webpack present?: #{File.exist? 'bin/webpack'}"
+    $stdout.puts "Is bin/webpack-dev-server present?: #{File.exist? 'bin/webpack-dev-server'}"
+    $stdout.puts "Is bin/yarn present?: #{File.exist? 'bin/yarn'}"
+  end
+end

data/lib/tasks/webpacker/install.rake

@@ -0,0 +1,13 @@
+install_template_path = File.expand_path("../../install/template.rb", __dir__).freeze
+
+namespace :webpacker do
+  desc "Install Webpacker in this application"
+  task install: [:check_node, :check_yarn] do
+    install_template_path = File.expand_path("../../install/template.rb", __dir__)
+
+    require "rails/generators"
+    require "rails/generators/rails/app/app_generator"
+    generator = Rails::Generators::AppGenerator.new [Jets.root], {force: ENV['FORCE']}, destination_root: Jets.root
+    generator.apply install_template_path, verbose: false
+  end
+end

data/lib/tasks/webpacker/verify_install.rake

@@ -0,0 +1,13 @@
+require "webpacker/configuration"
+
+namespace :webpacker do
+  desc "Verifies if Webpacker is installed"
+  task verify_install: [:check_node, :check_yarn, :check_binstubs] do
+    unless Webpacker.config.config_path.exist?
+      $stderr.puts "Configuration config/webpacker.yml file not found. \n"\
+           "Make sure webpacker:install is run successfully before " \
+           "running dependent tasks"
+      exit!
+    end
+  end
+end

data/lib/tasks/webpacker/yarn_install.rake

@@ -0,0 +1,21 @@
+namespace :webpacker do
+  desc "Support for older Rails versions. Install all JavaScript dependencies as specified via Yarn"
+  task :yarn_install do
+    system "yarn install --no-progress"
+
+    exit(1) unless $?.success?
+  end
+end
+
+def enhance_yarn_install
+  Rake::Task["yarn:install"].enhance do
+    exit(1) unless $?.success?
+  end
+end
+
+if Rake::Task.task_defined?("yarn:install")
+  enhance_yarn_install
+else
+  # this is mainly for pre-5.x era
+  Rake::Task.define_task("yarn:install" => "webpacker:yarn_install")
+end

data/lib/webpacker.rb

@@ -0,0 +1,46 @@
+require "active_support/core_ext/module/attribute_accessors"
+require "active_support/core_ext/string/inquiry"
+require "active_support/logger"
+require "active_support/tagged_logging"
+
+module Webpacker
+  extend self
+
+  def instance=(instance)
+    @instance = instance
+  end
+
+  def instance
+    @instance ||= Webpacker::Instance.new
+  end
+
+  def with_node_env(env)
+    original = ENV["NODE_ENV"]
+    ENV["NODE_ENV"] = env
+    yield
+  ensure
+    ENV["NODE_ENV"] = original
+  end
+
+  def ensure_log_goes_to_stdout
+    old_logger = Webpacker.logger
+    Webpacker.logger = ActiveSupport::Logger.new(STDOUT)
+    yield
+  ensure
+    Webpacker.logger = old_logger
+  end
+
+  delegate :logger, :logger=, :env, to: :instance
+  delegate :config, :compiler, :manifest, :commands, :dev_server, to: :instance
+  delegate :bootstrap, :clean, :clobber, :compile, to: :commands
+end
+
+require "webpacker/instance"
+require "webpacker/env"
+require "webpacker/configuration"
+require "webpacker/manifest"
+require "webpacker/compiler"
+require "webpacker/commands"
+require "webpacker/dev_server"
+
+# require "webpacker/railtie" if defined?(Rails)

data/lib/webpacker/commands.rb

@@ -0,0 +1,50 @@
+class Webpacker::Commands
+  delegate :config, :compiler, :manifest, :logger, to: :@webpacker
+
+  def initialize(webpacker)
+    @webpacker = webpacker
+  end
+
+  def clean(count = 2)
+    if config.public_output_path.exist? && config.public_manifest_path.exist? && versions.count > count
+      versions.drop(count).flat_map(&:last).each do |file|
+        File.delete(file) if File.file?(file)
+        logger.info "Removed #{file}"
+      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 versions
+      all_files       = Dir.glob("#{config.public_output_path}/**/*")
+      manifest_config = Dir.glob("#{config.public_manifest_path}*")
+
+      packs = all_files - manifest_config - current_version
+      packs.group_by { |file| File.mtime(file).utc.to_i }.sort.reverse
+    end
+
+    def current_version
+      manifest.refresh.values.map do |value|
+        next if value.is_a?(Hash)
+
+        File.join(config.root_path, "public", value)
+      end.compact
+    end
+end

data/lib/webpacker/compiler.rb

@@ -0,0 +1,107 @@
+require "open3"
+require "digest/sha1"
+
+class Webpacker::Compiler
+  # Additional paths that test compiler needs to watch
+  # Webpacker::Compiler.watched_paths << 'bower_components'
+  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, (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.
+        # See https://github.com/rails/webpacker/issues/2113
+        record_compilation_digest
+      end
+    else
+      logger.info "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
+  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
+      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
+
+    def record_compilation_digest
+      config.cache_path.mkpath
+      compilation_digest_path.write(watched_files_digest)
+    end
+
+    def run_webpack
+      logger.info "Compiling..."
+
+      stdout, stderr, status = Open3.capture3(
+        webpack_env,
+        "#{RbConfig.ruby} ./bin/webpack",
+        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 "Compilation failed:\n#{non_empty_streams.join("\n\n")}"
+      end
+
+      status.success?
+    end
+
+    def default_watched_paths
+      [
+        *config.resolved_paths_globbed,
+        config.source_path_globbed,
+        "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))
+    end
+end

data/lib/webpacker/configuration.rb

@@ -0,0 +1,113 @@
+require "yaml"
+require "active_support/core_ext/hash/keys"
+require "active_support/core_ext/hash/indifferent_access"
+
+class Webpacker::Configuration
+  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 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) }
+  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 extensions
+    fetch(:extensions)
+  end
+
+  def check_yarn_integrity=(value)
+    data[:check_yarn_integrity] = value
+  end
+
+  def check_yarn_integrity?
+    fetch(:check_yarn_integrity)
+  end
+
+  def webpack_compile_output?
+    fetch(:webpack_compile_output)
+  end
+
+  def extract_css?
+    fetch(:extract_css)
+  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
+
+    rescue Errno::ENOENT => e
+      raise "Webpacker configuration file not found #{config_path}. " \
+            "Please run rails webpacker:install " \
+            "Error: #{e.message}"
+
+    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 ||= \
+        HashWithIndifferentAccess.new(YAML.load_file(File.expand_path("../../install/config/webpacker.yml", __FILE__))[env])
+    end
+
+    def globbed_path_with_extensions(path)
+      "#{path}/**/*{#{extensions.join(',')}}"
+    end
+end