ember-cli-rails 0.13.2 → 0.14.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '01934a2a5a3ef903507625bbb0f2d3f7ad9d3bc80e026b2b127814d0c43e3945'
-  data.tar.gz: 3b03f7954e570fa28a5def013795b75541aa2e64b7bf81698936b91ad636fed4
+  metadata.gz: 89fb2f98a617de8c232e28b044db803f37f5a0b94147bdff07ebf45be3338d7f
+  data.tar.gz: 572e612fcac29c7cb1f4d74a28b40e839a07906a4bdca14d03ba1ba4e44c9577
 SHA512:
-  metadata.gz: 24d38e8a374602833f3955354b8aea2056d97f2f20da42926f9de96fd2b16da768833364211b9f3a0518a9c6ce51637ca94636a0675f9380d53f784395cf2b93
-  data.tar.gz: c12ff4d4cb60463d50ad52e1be2c68bf3a9b0e89bc5f7caceabba76fcb65cee4ff3b3cafff6ea0ab7db1a9c5427e821a40c30863890abfa81ab481e76f6540d8
+  metadata.gz: 631a8276c052830df276b0a53c4ccb46f2b80a6f71ef346002fe260222bc9f4852efc38ddab155c92af8a67e9efad2ab5c91124af2b34eb7cc942f418d097aeb
+  data.tar.gz: 1dbc29b10d0f912dd1f9d19419a00d6df87311d6d9e4d2b9448812848916ad53745e81900b7e538e894da77d58987ed7831a18d47da6b0f6476b8f87b4449af0

data/CHANGELOG.md

@@ -1,3 +1,54 @@
+0.14.1
+------
+
+* Build a Vite-based application with `vite build`, the command its own
+  `build` script runs, rather than with `ember build`. `ember build --help`
+  calls itself a "Vestigial command in Vite-based projects" and points at
+  that script. What the build writes is unchanged, and so is the classic
+  blueprint, which keeps building with `ember build`. The `silent` option
+  now quiets a Vite build with `--logLevel error`, which drops the progress
+  output and keeps the errors
+* Recognise an application as Vite-based from any of the six names Vite
+  resolves its configuration from, rather than only `vite.config.js`,
+  `vite.config.mjs` and `vite.config.ts`. An application configured in
+  `vite.config.mts`, `vite.config.cts` or `vite.config.cjs` was taken for a
+  classic one and served with `ember build --watch`, which a Vite-based
+  project rejects
+* Report the whole build failure of a classic application in the
+  `EmberCli::BuildError` message, instead of only its first line. Such an
+  application builds in the background, and `BuildMonitor` turns what
+  `ember build --watch` writes into the exception; the line naming the file
+  that failed to build is rarely the first one, so a parse error arrived
+  with its message and line number but no way to tell which file it came
+  from
+* Pass `--watcher` to `ember build` only when the build watches. The flag
+  names the backend that watches the file system, so it did nothing for a
+  one-off build
+
+0.14.0
+------
+
+* Add the `package_manager` option to install an application's NodeJS
+  dependencies with pnpm (`package_manager: :pnpm`), yarn, or npm. `pnpm_path`
+  implies pnpm the way `yarn_path` implies yarn. The package manager is read
+  through the new `EmberCli::App#package_manager` and `EmberCli::App#pnpm?`
+* Deprecate `yarn: true` in favour of `package_manager: :yarn`. The shorthand
+  still selects yarn, with a deprecation warning, and will be removed in `1.0`
+* Identify a project with a pnpm application to Heroku's NodeJS buildpack
+  from `rails generate ember:heroku`, with a root-level `pnpm-lock.yaml`, and
+  pin the package manager version in the generated `package.json` from the
+  `packageManager` the Ember applications declare, read through the new
+  `EmberCli::App#package_manager_spec`
+* Stop adding `rails_12factor` to the `Gemfile` from `rails generate
+  ember:heroku`. Rails serves the twelve-factor behaviour the gem backported
+  natively since `5.0`, and every Rails version this gem supports is `>= 5.2`.
+  To upgrade, remove `rails_12factor` from your project's `Gemfile`
+* Replace `EmberCli::App#yarn_enabled?` with `EmberCli::App#yarn?`
+* Pin the NodeJS version in the `package.json` that `rails generate
+  ember:heroku` writes, from the `engines.node` the Ember applications
+  declare, read through the new `EmberCli::App#node_engine`. Applications
+  that declare different versions are left unpinned
+
 0.13.2
 ------
 

data/README.md

@@ -77,9 +77,14 @@ c.app :frontend, path: "~/projects/my-ember-app"
 - `path` - the path where your Ember CLI application is located. The default
   value is the name of your app in the Rails root.
 
-- `silent` - this provides `--silent` option for Ember CLI commands to control verbosity of their output.
+- `silent` - quiets the build. A classic application is built with
+  `ember build --silent`; a Vite-based one with `vite build --logLevel error`,
+  which keeps errors while dropping the progress output.
 
-- `yarn` - enables the [yarn](https://github.com/yarnpkg/yarn) package manager when installing dependencies
+- `package_manager` - the package manager that installs the application's
+  NodeJS dependencies: `:npm` (the default), `:yarn`, or `:pnpm`. Name the
+  executable with `npm_path`, `yarn_path`, or `pnpm_path` when it is not on
+  the `$PATH`.
 
 - `dev_server` - configures [Vite's development server](#vite-based-applications)
   for Vite-based applications in `development`. Pass `false` to opt out of it,
@@ -364,9 +369,7 @@ To configure your EmberCLI-Rails applications for Heroku:
 
 1. Execute `rails generate ember:heroku`.
 1. Commit the newly generated files.
-1. [Add the NodeJS buildpack][buildpack] and configure NPM to include the
-   `bower` dependency's executable file (if your build process requires
-   `bower`).
+1. [Add the NodeJS buildpack][buildpack].
 
 ```sh
 $ heroku buildpacks:clear
@@ -381,11 +384,30 @@ You are ready to deploy:
 $ git push heroku master
 ```
 
-EmberCLI compilation happens at deploy-time, triggered by the `asset:precompile` rake task.
+EmberCLI compilation happens at deploy-time, triggered by the
+`assets:precompile` rake task. This is the same for both build systems: Vite's
+[development server](#vite-based-applications) only runs in `development`, so
+a Vite-based application deploys exactly like a classic one — `ember build`
+writes to the build directory, and Rails serves the result.
 
 **NOTE** Run the generator each time you introduce additional EmberCLI
 applications into the project.
 
+**Package manager** — the buildpack installs the package manager the *project
+root's* lockfile names. The generator writes an empty `yarn.lock` or
+`pnpm-lock.yaml` when an application is configured with yarn or pnpm as its
+`package_manager`, and copies the `packageManager` field the Ember
+applications declare into the generated `package.json` so that the buildpack
+installs that version. Without a `packageManager` field the buildpack installs
+the latest pnpm release.
+
+**NodeJS version** — the buildpack reads `engines.node` from the *project
+root's* `package.json` (the file the generator writes), not from the Ember
+application's, and builds on the current LTS release when it names no version.
+Make sure the generated file requires a NodeJS that satisfies your Ember
+application's own `engines.node`: applications generated with `ember-cli >=
+6.8` require NodeJS `>= 20.19.0`.
+
 [buildpack]: https://devcenter.heroku.com/articles/using-multiple-buildpacks-for-an-app#adding-a-buildpack
 
 #### Slug size
@@ -400,12 +422,14 @@ A build-pack solution for this is discussed in [Issue #491][#491].
 
 ### Capistrano
 
-EmberCLI-Rails executes both `npm install` and `bower install` during EmberCLI's
-compilation, triggered by the  `asset:precompile` rake task.
+EmberCLI-Rails installs the Ember application's NodeJS dependencies during
+EmberCLI's compilation, triggered by the `assets:precompile` rake task. It runs
+`npm install`, `yarn install`, or `pnpm install`, as the application's
+`package_manager` option names.
 
-The `npm` and `bower` executables are required to be defined in the deployment
-SSH session's `$PATH`. It is not sufficient to modify the session's `$PATH` in
-a `.bash_profile`.
+The executables it runs are required to be defined in the deployment SSH
+session's `$PATH`. It is not sufficient to modify the session's `$PATH` in a
+`.bash_profile`.
 
 To resolve this issue, prepend the Node installation's `bin` directory to the
 target system's `$PATH`:
@@ -414,26 +438,26 @@ target system's `$PATH`:
 #config/deploy/production.rb
 
 set :default_env, {
-  "PATH" => "/home/deploy/.nvm/versions/node/v4.2.1/bin:$PATH"
+  "PATH" => "/home/deploy/.nvm/versions/node/v22.11.0/bin:$PATH"
 }
 ```
 
 The system in this example is using `nvm` to configure the node version. If
 you're not using `nvm`, make sure the string you prepend to the `$PATH` variable
-contains the directory or directories that contain the `bower` and `npm`
-executables.
+contains the directory or directories that contain the executables above. Point
+it at a NodeJS that satisfies the Ember application's `engines.node`:
+applications generated with `ember-cli >= 6.8` require NodeJS `>= 20.19.0`.
 
 #### For faster deployments
 
 Place the following in your `deploy/<environment>.rb`
 
 ```ruby
-set :linked_dirs, %w{<ember-app-name>/node_modules <ember-app-name>/bower_components}
+set :linked_dirs, %w{<ember-app-name>/node_modules}
 ```
 
-to avoid rebuilding all the node modules and bower components with every deploy.
-Replace `<ember-app-name>` with the name of your ember app (default is
-`frontend`).
+to avoid rebuilding all the node modules with every deploy. Replace
+`<ember-app-name>` with the name of your ember app (default is `frontend`).
 
 ## Override
 

data/lib/ember_cli/app.rb

@@ -1,3 +1,5 @@
+require "json"
+
 require "html_page/renderer"
 require "ember_cli/path_set"
 require "ember_cli/shell"
@@ -91,14 +93,33 @@ module EmberCli
       deploy.mountable?
     end
 
-    def yarn_enabled?
-      options.fetch(:yarn, false)
+    def package_manager
+      paths.package_manager
+    end
+
+    def yarn?
+      paths.yarn?
+    end
+
+    def pnpm?
+      paths.pnpm?
     end
 
     def bower?
       paths.bower_json.exist?
     end
 
+    def node_engine
+      package_json_value("engines", "node")
+    end
+
+    # The `packageManager` field of the application's `package.json`, such as
+    # `"pnpm@10.0.0"`: the package manager version Corepack and Heroku's
+    # NodeJS buildpack install.
+    def package_manager_spec
+      package_json_value("packageManager")
+    end
+
     def to_rack
       deploy.to_rack
     end
@@ -123,6 +144,16 @@ module EmberCli
 
     private
 
+    def package_json_value(*keys)
+      package_json = paths.package_json
+
+      if package_json.exist?
+        JSON.parse(package_json.read).dig(*keys)
+      end
+    rescue JSON::ParserError
+      nil
+    end
+
     def development?
       env.to_s == "development"
     end

data/lib/ember_cli/build_monitor.rb

@@ -41,6 +41,7 @@ module EmberCli
 
     def build_errors
       error_lines.
+        map(&:chomp).
         reject { |line| is_blank_or_backtrace?(line) }.
         reject { |line| is_deprecation_warning?(line) }.
         reject { |line| is_building_notice?(line) }
@@ -75,11 +76,11 @@ module EmberCli
     end
 
     def raise_build_error!
-      backtrace = build_errors.first
-      message = "#{name.inspect} has failed to build: #{backtrace}"
+      errors = build_errors
+      message = "#{name.inspect} has failed to build: #{errors.join("\n")}"
 
       error = BuildError.new(message)
-      error.set_backtrace(backtrace)
+      error.set_backtrace(errors)
 
       fail error
     end

data/lib/ember_cli/command.rb

@@ -14,7 +14,11 @@ module EmberCli
     end
 
     def build(watch: false)
-      ember_build(watch: watch)
+      if paths.vite?
+        vite_build
+      else
+        ember_build(watch: watch)
+      end
     end
 
     # Boots Vite's development server for an application generated with the
@@ -43,11 +47,53 @@ module EmberCli
       options.fetch(:silent) { false }
     end
 
+    def build_environment
+      if EmberCli.env == "production"
+        "production"
+      else
+        "development"
+      end
+    end
+
+    # The Vite-based blueprint (`ember-cli >= 6.8`)
+    #
+    # Builds the application the way its own `build` script does.
+    # `ember build` still drives such a build today, but `ember build --help`
+    # calls it a "Vestigial command in Vite-based projects" and has dropped
+    # every option but `--environment`, `--suppress-sizes` and
+    # `--output-path`.
+    #
+    # `--emptyOutDir` is needed because the output directory is outside the
+    # Ember application, where Vite leaves stale files in place unless asked
+    # to clear them.
+    def vite_build
+      line = Terrapin::CommandLine.new(paths.vite, [
+        "build",
+        "--mode :mode",
+        "--outDir :output_path",
+        "--emptyOutDir",
+        ("--logLevel error" if silent?),
+      ].compact.join(" "))
+
+      line.command(
+        mode: build_environment,
+        output_path: paths.dist,
+      )
+    end
+
+    # The classic blueprint
+    #
+    # Builds the application with `ember build`, which watches for changes
+    # when asked. A Vite-based project has no equivalent: `ember build` there
+    # refuses `--watch`, and its development server watches instead.
+    #
+    # `--watcher` names the backend that watches, so it rides along only
+    # when the build watches.
     def ember_build(watch: false)
       line = Terrapin::CommandLine.new(paths.ember, [
         "build",
         ("--watch" if watch),
-        ("--watcher :watcher" if process_watcher),
+        ("--watcher :watcher" if watch && process_watcher),
         ("--silent" if silent?),
         "--environment :environment",
         "--output-path :output_path",
@@ -59,13 +105,5 @@ module EmberCli
         watcher: process_watcher,
       )
     end
-
-    def build_environment
-      if EmberCli.env == "production"
-        "production"
-      else
-        "development"
-      end
-    end
   end
 end

data/lib/ember_cli/engine.rb

@@ -3,5 +3,13 @@ module EmberCli
     initializer "ember-cli-rails.setup" do
       require "ember_cli/route_helpers"
     end
+
+    # Rails 7.1 and later manage the deprecators of engines with the
+    # application's own, so that `config.active_support.deprecation` applies.
+    initializer "ember-cli-rails.deprecator" do |app|
+      if app.respond_to?(:deprecators)
+        app.deprecators[:ember_cli_rails] = EmberCli.deprecator
+      end
+    end
   end
 end

data/lib/ember_cli/path_set.rb

@@ -2,6 +2,26 @@ require "ember_cli/helpers"
 
 module EmberCli
   class PathSet
+    PACKAGE_MANAGERS = %i[npm yarn pnpm].freeze
+
+    # Every name Vite resolves its configuration file from. An application
+    # that keeps its configuration under any of them is Vite-based.
+    VITE_CONFIG_FILES = %w[
+      vite.config.js
+      vite.config.mjs
+      vite.config.cjs
+      vite.config.ts
+      vite.config.mts
+      vite.config.cts
+    ].freeze
+
+    # npm ships with NodeJS, so it has no installation instructions of its own
+    # to point at when its executable is missing.
+    INSTALL_INSTRUCTIONS = {
+      yarn: "https://yarnpkg.com/lang/en/docs/install/",
+      pnpm: "https://pnpm.io/installation",
+    }.freeze
+
     def initialize(app:, rails_root:, ember_cli_root:, environment:)
       @app = app
       @rails_root = rails_root
@@ -35,6 +55,10 @@ module EmberCli
       @gemfile ||= root.join("Gemfile")
     end
 
+    def package_json
+      @package_json ||= root.join("package.json")
+    end
+
     def bower_json
       root.join("bower.json")
     end
@@ -42,8 +66,7 @@ module EmberCli
     # Apps generated with the Vite-based blueprint (`ember-cli >= 6.8`)
     # ship a Vite config file at their root.
     def vite?
-      %w[vite.config.mjs vite.config.js vite.config.ts].
-        any? { |config| root.join(config).exist? }
+      VITE_CONFIG_FILES.any? { |config| root.join(config).exist? }
     end
 
     def ember
@@ -117,21 +140,59 @@ module EmberCli
 
     def yarn
       if yarn?
-        @yarn ||= path_for_executable("yarn").tap do |yarn|
-          unless File.executable?(yarn.to_s)
-            fail DependencyError.new(<<-MSG.strip_heredoc)
-                EmberCLI has been configured to install NodeJS dependencies with Yarn, but the Yarn executable is unavailable.
+        @yarn ||= package_manager_executable(:yarn)
+      end
+    end
+
+    def pnpm
+      if pnpm?
+        @pnpm ||= package_manager_executable(:pnpm)
+      end
+    end
 
-                Install it by following the instructions at https://yarnpkg.com/lang/en/docs/install/
+    def node_modules
+      @node_modules ||= root.join("node_modules")
+    end
 
-            MSG
+    # The package manager that installs the application's NodeJS
+    # dependencies: the one the `package_manager` option names, else the one
+    # whose executable a `yarn_path` or `pnpm_path` option names, else npm.
+    # The deprecated `yarn: true` still selects yarn, with a warning.
+    def package_manager
+      @package_manager ||= begin
+        requested = app_options[:package_manager]
+
+        if requested.present?
+          requested.to_s.to_sym.tap do |name|
+            unless PACKAGE_MANAGERS.include?(name)
+              fail ArgumentError,
+                "Unsupported package manager #{requested.inspect} for " \
+                "`#{app_name}`; use one of #{PACKAGE_MANAGERS.inspect}"
+            end
           end
+        elsif app_options[:yarn].present?
+          EmberCli.deprecator.warn(
+            "The `yarn` option of the `#{app_name}` Ember application is " \
+            "deprecated; configure it with `package_manager: :yarn` instead",
+          )
+
+          :yarn
+        elsif app_options[:yarn_path].present?
+          :yarn
+        elsif app_options[:pnpm_path].present?
+          :pnpm
+        else
+          :npm
         end
       end
     end
 
-    def node_modules
-      @node_modules ||= root.join("node_modules")
+    def yarn?
+      package_manager == :yarn
+    end
+
+    def pnpm?
+      package_manager == :pnpm
     end
 
     def tee
@@ -161,16 +222,17 @@ module EmberCli
       end
     end
 
-    def package_manager
-      if yarn?
-        "yarn"
-      else
-        "npm"
-      end
-    end
+    def package_manager_executable(name)
+      path_for_executable(name.to_s).tap do |path|
+        unless File.executable?(path.to_s)
+          fail DependencyError.new(<<-MSG.strip_heredoc)
+              EmberCLI has been configured to install NodeJS dependencies with #{name}, but the #{name} executable is unavailable.
 
-    def yarn?
-      app_options[:yarn] || app_options[:yarn_path]
+              Install it by following the instructions at #{INSTALL_INSTRUCTIONS.fetch(name)}
+
+          MSG
+        end
+      end
     end
 
     def app_name

data/lib/ember_cli/shell.rb

@@ -69,8 +69,11 @@ module EmberCli
         clean_ember_dependencies!
       end
 
-      if paths.yarn
+      case paths.package_manager
+      when :yarn
         run! "#{paths.yarn} install"
+      when :pnpm
+        run! "#{paths.pnpm} install"
       else
         run! "#{paths.npm} prune && #{paths.npm} install"
       end

data/lib/ember_cli/version.rb

@@ -1,3 +1,3 @@
 module EmberCli
-  VERSION = "0.13.2".freeze
+  VERSION = "0.14.1".freeze
 end

data/lib/ember_cli.rb

@@ -1,4 +1,5 @@
 require "fileutils"
+require "active_support/deprecation"
 require "ember-cli-rails-assets"
 require "ember_cli/engine"
 require "ember_cli/configuration"
@@ -16,6 +17,10 @@ module EmberCli
     Configuration.instance
   end
 
+  def deprecator
+    @deprecator ||= ActiveSupport::Deprecation.new("1.0", "ember-cli-rails")
+  end
+
   def app(name)
     apps.fetch(name) do
       fail KeyError, "#{name.inspect} app is not defined"

data/lib/generators/ember/heroku/USAGE

@@ -1,18 +1,26 @@
 Description:
     Configures a project for deploying to Heroku.
 
-    Once the generator is complete, execute the following:
+    Once the generator is complete, add the buildpacks the deploy needs:
 
         $ heroku buildpacks:clear
         $ heroku buildpacks:add --index 1 heroku/nodejs
         $ heroku buildpacks:add --index 2 heroku/ruby
+
+    `SKIP_EMBER` skips the build wherever it is set. Unset it on the Heroku
+    application, so that `assets:precompile` compiles the EmberCLI
+    applications at deploy time:
+
         $ heroku config:unset SKIP_EMBER
 
 Example:
     rails generate ember:heroku
 
-    This will install the following gems:
-        rails_12factor
-
     This will create:
         package.json
+
+    An application configured with `yarn` also creates:
+        yarn.lock
+
+    Run the generator again whenever you add an EmberCLI application: the
+    generated `cacheDirectories` names each application's `node_modules`.

data/lib/generators/ember/heroku/heroku_generator.rb

@@ -9,17 +9,53 @@ module EmberCli
     end
 
     def identify_as_yarn_project
-      if EmberCli.any?(&:yarn_enabled?)
+      if EmberCli.any?(&:yarn?)
         template "yarn.lock.erb", "yarn.lock"
       end
     end
 
-    def inject_12factor_gem
-      gem "rails_12factor", group: [:staging, :production]
+    def identify_as_pnpm_project
+      if EmberCli.any?(&:pnpm?)
+        template "pnpm-lock.yaml.erb", "pnpm-lock.yaml"
+      end
     end
 
     private
 
+    def node_engine
+      unless defined?(@node_engine)
+        @node_engine = shared_declaration("engines.node", &:node_engine)
+      end
+
+      @node_engine
+    end
+
+    def package_manager_spec
+      unless defined?(@package_manager_spec)
+        @package_manager_spec = shared_declaration("packageManager", &:package_manager_spec)
+      end
+
+      @package_manager_spec
+    end
+
+    # The value every Ember application declares for a `package.json` field, or nil when they declare different ones:
+    # the generated `package.json` can only carry one, and picking either would silently break the other application's build.
+    def shared_declaration(field)
+      declared = apps.map { |app| yield app }.compact.uniq
+
+      if declared.size > 1
+        say_status(
+          :conflict,
+          "Ember applications declare different `#{field}` (#{declared.join(", ")}); pin one in package.json by hand",
+          :red,
+        )
+
+        nil
+      else
+        declared.first
+      end
+    end
+
     def cache_directories
       all_cached_directories.map do |cached_directory|
         cached_directory.relative_path_from(Rails.root).to_s
@@ -38,12 +74,6 @@ module EmberCli
       [Rails.root.join("node_modules")]
     end
 
-    def app_paths
-      EmberCli.apps.values.map do |app|
-        app.root_path.relative_path_from(Rails.root)
-      end
-    end
-
     def apps
       EmberCli.apps.values
     end

data/lib/generators/ember/heroku/templates/package.json.erb

@@ -4,5 +4,13 @@
     "bower": "*"
   },
   <% end %>
+  <% if package_manager_spec %>
+  "packageManager": <%= package_manager_spec.to_json %>,
+  <% end %>
+  <% if node_engine %>
+  "engines": {
+    "node": <%= node_engine.to_json %>
+  },
+  <% end %>
   "cacheDirectories": <%= cache_directories.to_json %>
 }

data/lib/generators/ember/heroku/templates/pnpm-lock.yaml.erb

@@ -0,0 +1 @@
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ember-cli-rails
 version: !ruby/object:Gem::Version
-  version: 0.13.2
+  version: 0.14.1
 platform: ruby
 authors:
 - Pavel Pravosud
@@ -194,6 +194,7 @@ files:
 - lib/generators/ember/heroku/USAGE
 - lib/generators/ember/heroku/heroku_generator.rb
 - lib/generators/ember/heroku/templates/package.json.erb
+- lib/generators/ember/heroku/templates/pnpm-lock.yaml.erb
 - lib/generators/ember/heroku/templates/yarn.lock.erb
 - lib/generators/ember/init/USAGE
 - lib/generators/ember/init/init_generator.rb
@@ -217,7 +218,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.20
+rubygems_version: 4.0.16
 specification_version: 4
 summary: Integration between Ember CLI and Rails
 test_files: []