webpacker-react-on-rails 2.0

data/lib/tasks/installers.rake

@@ -0,0 +1,22 @@
+INSTALLERS = {
+  "Angular": :angular,
+  "Elm": :elm,
+  "React": :react,
+  "Vue": :vue
+}.freeze
+
+namespace :webpacker do
+  namespace :install do
+    INSTALLERS.each do |name, task_name|
+      desc "Install everything needed for #{name}"
+      task task_name => ["webpacker:verify_install"] do
+        template = File.expand_path("../install/#{task_name}.rb", __dir__)
+        if Rails::VERSION::MAJOR >= 5
+          exec "#{RbConfig.ruby} ./bin/rails app:template LOCATION=#{template}"
+        else
+          exec "#{RbConfig.ruby} ./bin/rake rails:template LOCATION=#{template}"
+        end
+      end
+    end
+  end
+end

data/lib/tasks/webpacker.rake

@@ -0,0 +1,19 @@
+tasks = {
+  "webpacker:install"                 => "Installs and setup webpack with yarn",
+  "webpacker:compile"                 => "Compiles webpack bundles based on environment",
+  "webpacker:check_node"              => "Verifies if Node.js is installed",
+  "webpacker:check_yarn"              => "Verifies if yarn is installed",
+  "webpacker:check_binstubs"          => "Verifies that bin/webpack & bin/webpack-dev-server are present",
+  "webpacker:verify_install"          => "Verifies if webpacker is installed",
+  "webpacker:yarn_install"            => "Support for older Rails versions. Install all JavaScript dependencies as specified via Yarn",
+  "webpacker:install:react"           => "Installs and setup example React component",
+  "webpacker:install:vue"             => "Installs and setup example Vue component",
+  "webpacker:install:angular"         => "Installs and setup example Angular component",
+  "webpacker:install:elm"             => "Installs and setup example Elm component"
+}.freeze
+
+desc "Lists all available tasks in webpacker"
+task :webpacker do
+  puts "Available webpacker tasks are:"
+  tasks.each { |task, message| puts task.ljust(30) + message }
+end

data/lib/tasks/webpacker/check_binstubs.rake

@@ -0,0 +1,12 @@
+namespace :webpacker do
+  desc "Verifies that bin/webpack & bin/webpack-dev-server are present."
+  task :check_binstubs do
+    unless File.exist?("bin/webpack") && File.exist?("bin/webpack-dev-server")
+      $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,20 @@
+namespace :webpacker do
+  desc "Verifies if Node.js is installed"
+  task :check_node do
+    begin
+      node_version = `node -v`
+      node_version = `nodejs -v` if node_version.blank?
+      required_node_version = "6.4"
+
+      raise Errno::ENOENT if node_version.blank?
+      if Gem::Version.new(node_version.strip.tr("v", "")) < Gem::Version.new(required_node_version)
+        $stderr.puts "Webpacker requires Node.js >= v#{required_node_version} and you are using #{node_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,15 @@
+namespace :webpacker do
+  desc "Verifies if yarn is installed"
+  task :check_yarn do
+    required_yarn_version = "0.20.1"
+
+    begin
+      yarn_version = `yarn --version`
+
+      raise Errno::ENOENT if yarn_version.blank? || Gem::Version.new(yarn_version) < Gem::Version.new(required_yarn_version)
+    rescue Errno::ENOENT
+      $stderr.puts "Webpacker requires Yarn version >= #{required_yarn_version}. Please download and install the latest version from https://yarnpkg.com/lang/en/docs/install/"
+      $stderr.puts "Exiting!" && exit!
+    end
+  end
+end

data/lib/tasks/webpacker/clobber.rake

@@ -0,0 +1,17 @@
+require "webpacker/configuration"
+
+namespace :webpacker do
+  desc "Remove the webpack compiled output directory"
+  task clobber: ["webpacker:verify_install", :environment] do
+    output_path = Webpacker::Configuration.output_path
+    FileUtils.rm_r(output_path) if File.exist?(output_path)
+    $stdout.puts "Removed webpack output path directory #{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,38 @@
+$stdout.sync = true
+
+require "open3"
+require "webpacker/env"
+require "webpacker/configuration"
+
+namespace :webpacker do
+  desc "Compile javascript packs using webpack for production with digests"
+  task compile: ["webpacker:verify_install", :environment] do
+    $stdout.puts "[Webpacker] Compiling assets 🎉"
+
+    asset_host = ActionController::Base.helpers.compute_asset_host
+    env = { "NODE_ENV" => Webpacker.env, "ASSET_HOST" => asset_host }.freeze
+
+    stdout_str, stderr_str, status = Open3.capture3(env, "./bin/webpack")
+
+    if status.success?
+      $stdout.puts "\e[32m[Webpacker] Compiled digests for all packs in #{Webpacker::Configuration.entry_path}:\e[0m"
+      $stdout.puts "\e[32m#{JSON.parse(File.read(Webpacker::Configuration.manifest_path))}\e[0m"
+    else
+      $stdout.puts "[Webpacker] Compilation Failed"
+      $stdout.puts "\e[31m#{stdout_str}\e[0m"
+      $stderr.puts "\e[31m#{stderr_str}\e[0m"
+      exit!
+    end
+  end
+end
+
+# Compile packs after we've compiled all other assets during precompilation
+if Rake::Task.task_defined?("assets:precompile")
+  Rake::Task["assets:precompile"].enhance do
+    unless Rake::Task.task_defined?("yarn:install")
+      # For Rails < 5.1
+      Rake::Task["webpacker:yarn_install"].invoke
+    end
+    Rake::Task["webpacker:compile"].invoke
+  end
+end

data/lib/tasks/webpacker/install.rake

@@ -0,0 +1,12 @@
+WEBPACKER_APP_TEMPLATE_PATH = File.expand_path("../../install/template.rb", __dir__)
+
+namespace :webpacker do
+  desc "Install webpacker in this application"
+  task install: [:check_node, :check_yarn] do
+    if Rails::VERSION::MAJOR >= 5
+      exec "#{RbConfig.ruby} ./bin/rails app:template LOCATION=#{WEBPACKER_APP_TEMPLATE_PATH}"
+    else
+      exec "#{RbConfig.ruby} ./bin/rake rails:template LOCATION=#{WEBPACKER_APP_TEMPLATE_PATH}"
+    end
+  end
+end

data/lib/tasks/webpacker/verify_install.rake

@@ -0,0 +1,16 @@
+require "webpacker/configuration"
+
+namespace :webpacker do
+  desc "Verifies if webpacker is installed"
+  task verify_install: [:check_node, :check_yarn, :check_binstubs] do
+    if File.exist?(Webpacker::Configuration.file_path)
+      $stdout.puts "Webpacker is installed 🎉 🍰"
+      $stdout.puts "Using #{Webpacker::Configuration.file_path} file for setting up webpack paths"
+    else
+      $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,6 @@
+namespace :webpacker do
+  desc "Support for older Rails versions.Install all JavaScript dependencies as specified via Yarn"
+  task :yarn_install, [:arg1, :arg2] do |task, args|
+    system "yarn #{args[:arg1]} #{args[:arg2]}"
+  end
+end

data/lib/webpacker.rb

@@ -0,0 +1,26 @@
+module Webpacker
+  extend self
+
+  def bootstrap
+    Webpacker::Env.load_instance
+    Webpacker::Configuration.load_instance
+    Webpacker::DevServer.load_instance
+    Webpacker::Manifest.load_instance
+  end
+
+  def compile
+    Webpacker::Compiler.compile
+    Webpacker::Manifest.load_instance
+  end
+
+  def env
+    Webpacker::Env.current.inquiry
+  end
+end
+
+require "webpacker/env"
+require "webpacker/configuration"
+require "webpacker/dev_server"
+require "webpacker/manifest"
+require "webpacker/compiler"
+require "webpacker/railtie" if defined?(Rails)

data/lib/webpacker/compiler.rb

@@ -0,0 +1,59 @@
+require "rake"
+
+module Webpacker::Compiler
+  extend self
+
+  # Additional paths that test compiler needs to watch
+  # Webpacker::Compiler.watched_paths << 'bower_components'
+  mattr_accessor(:watched_paths) { [] }
+
+  # Compiler cache directory
+  # Webpacker::Compiler.cache_dir = 'tmp/cache'
+  mattr_accessor(:cache_dir) { "tmp/webpacker" }
+
+  def compile
+    return unless compile?
+    cache_source_timestamp
+    compile_task.invoke
+    compile_task.reenable
+  end
+
+  def compile?
+    return true unless File.exist?(cached_timestamp_path)
+    return true unless File.exist?(Webpacker::Configuration.output_path)
+
+    File.read(cached_timestamp_path) != current_source_timestamp
+  end
+
+  def default_watched_paths
+    ["#{Webpacker::Configuration.source}/**/*", "yarn.lock", "package.json", "config/webpack/**/*"].freeze
+  end
+
+  private
+    def current_source_timestamp
+      files = Dir[*default_watched_paths, *watched_paths].reject { |f| File.directory?(f) }
+      files.map { |f| File.mtime(f).utc.to_i }.max.to_s
+    end
+
+    def cache_source_timestamp
+      File.write(cached_timestamp_path, current_source_timestamp)
+    end
+
+    def cached_timestamp_path
+      FileUtils.mkdir_p(cache_dir) unless File.directory?(cache_dir)
+      Rails.root.join(cache_dir, ".compiler-timestamp")
+    end
+
+    def compile_task
+      @compile_task ||= load_rake_task("webpacker:compile")
+    end
+
+    def load_rake_task(name)
+      load_rakefile unless Rake::Task.task_defined?(name)
+      Rake::Task[name]
+    end
+
+    def load_rakefile
+      @load_rakefile ||= Rake.load_rakefile(Rails.root.join("Rakefile"))
+    end
+end

data/lib/webpacker/configuration.rb

@@ -0,0 +1,83 @@
+# Loads webpacker configuration from config/webpacker.yml
+
+require "webpacker/file_loader"
+
+class Webpacker::Configuration < Webpacker::FileLoader
+  class << self
+    def reset
+      @defaults = nil
+      super
+    end
+
+    def entry_path
+      source_path.join(fetch(:source_entry_path))
+    end
+
+    def public_output_path
+      fetch(:public_output_path)
+    end
+
+    def output_path
+      public_path.join(public_output_path)
+    end
+
+    def manifest_path
+      output_path.join("manifest.json")
+    end
+
+    def source_path
+      Rails.root.join(source)
+    end
+
+    def public_path
+      Rails.root.join("public")
+    end
+
+    def file_path(root: Rails.root)
+      root.join("config/webpacker.yml")
+    end
+
+    def default_file_path
+      file_path(root: Pathname.new(__dir__).join("../install"))
+    end
+
+    def source
+      fetch(:source_path)
+    end
+
+    def compile?
+      fetch(:compile)
+    end
+
+    def fetch(key)
+      data.fetch(key, defaults[key])
+    end
+
+    def data
+      load_instance if Webpacker.env.development?
+      raise Webpacker::FileLoader::FileLoaderError.new("Webpacker::Configuration.load_data must be called first") unless instance
+      instance.data
+    end
+
+    def defaults
+      @defaults ||= HashWithIndifferentAccess.new(YAML.load(default_file_path.read)[Webpacker.env])
+    end
+
+    # Uses the webpack dev server host if appropriate
+    def output_path_or_url
+      if Webpacker::DevServer.dev_server?
+        Webpacker::DevServer.base_url
+      else
+        # Ensure we start with a slash so that the asset helpers don't prepend the default asset
+        # pipeline locations.
+        public_output_path.starts_with?("/") ? public_output_path : "/#{public_output_path}"
+      end
+    end
+  end
+
+  private
+    def load_data
+      return Webpacker::Configuration.defaults unless File.exist?(@path)
+      HashWithIndifferentAccess.new(YAML.load(File.read(@path))[Webpacker.env])
+    end
+end

data/lib/webpacker/dev_server.rb

@@ -0,0 +1,78 @@
+# Same convention as manifest/configuration.rb
+
+# Loads webpacker configuration from config/webpacker.yml
+
+require "webpacker/configuration"
+
+class Webpacker::DevServer < Webpacker::FileLoader
+  class << self
+    def dev_server?
+      !dev_server_values.nil?
+    end
+
+    # read settings for dev_server
+    def hot?
+      return false unless dev_server?
+      if ENV["WEBPACKER_HMR"].present?
+        val = ENV["WEBPACKER_HMR"].downcase
+        return true if val == "true"
+        return false if val == "false"
+        raise new ArgumentError("WEBPACKER_HMR value is #{ENV['WEBPACKER_HMR']}. Set to TRUE|FALSE")
+      end
+      fetch(:hot)
+    end
+
+    def host
+      fetch(:host)
+    end
+
+    def port
+      fetch(:port)
+    end
+
+    def https?
+      fetch(:https)
+    end
+
+    def protocol
+      https? ? "https" : "http"
+    end
+
+    def file_path
+      Webpacker::Configuration.file_path
+    end
+
+    # Uses the hot_reloading_host if appropriate
+    def base_url
+      "#{protocol}://#{host}:#{port}"
+    end
+
+    private
+
+    def dev_server_values
+      data.fetch(:dev_server, nil)
+    end
+
+    def fetch(key)
+      return nil unless dev_server?
+      dev_server_values.fetch(key, dev_server_defaults[key])
+    end
+
+    def data
+      load_instance if Webpacker.env.development?
+      unless instance
+        raise Webpacker::FileLoader::FileLoaderError.new("Webpacker::DevServer.load_data must be called first")
+      end
+      instance.data
+    end
+
+    def dev_server_defaults
+      @defaults ||= Webpacker::Configuration.defaults[:dev_server]
+    end
+  end
+
+  private
+    def load_data
+      Webpacker::Configuration.instance.data
+    end
+end

data/lib/webpacker/env.rb

@@ -0,0 +1,23 @@
+# Singleton registry for determining NODE_ENV from config/webpacker.yml
+require "webpacker/file_loader"
+
+class Webpacker::Env < Webpacker::FileLoader
+  class << self
+    def current
+      raise Webpacker::FileLoader::FileLoaderError.new("Webpacker::Env.load must be called first") unless instance
+      instance.data
+    end
+
+    def file_path
+      Rails.root.join("config", "webpacker.yml")
+    end
+  end
+
+  private
+    def load_data
+      environments = File.exist?(@path) ? YAML.load(File.read(@path)).keys : [].freeze
+      return ENV["NODE_ENV"] if environments.include?(ENV["NODE_ENV"])
+      return Rails.env if environments.include?(Rails.env)
+      "production"
+    end
+end