ember-cli-rails 0.13.0.beta1 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 89b0e32290ff43666d7f220c5cd91b0ea8fb6a544bd353f6a3f65d9c5daf9823
-  data.tar.gz: 20d38958d7e6efec4f53dcc36f0af29a00021402cef02247b157481cba158e1f
+  metadata.gz: 88933ba7736d53f0cf1f9fc79e6b9997469517188a1b904571222f7e57d15091
+  data.tar.gz: fdd038c1e831096567b4bbdef03ed722c40ff11da77e87a29c3059073109d620
 SHA512:
-  metadata.gz: 7e46c51bbd566dfdb337227ab884eab7d9a037fb8dc08ba1e4f970694ce0ef02eebe9f777683ef997efb638c0b0dafdad083507491f0831f2e67a4fa8ae4aef1
-  data.tar.gz: 58a951962724029db87ed4bf969e85bcef65babb964ffedc05a13c5093c0da31cce85a98724b41a38b4116b0b4fc94998d696aadd9da00cfc0c79da2742e1bb5
+  metadata.gz: 10ad87d14effd255d9b13ecfd73ed2a26290199ea410d3204280cee51a2e90dd39c9802cf2201787d119fbafd7da10b29fee6d9e2305f6cf67d81b9946e8c0df
+  data.tar.gz: e6deabf31ce35858c53174386ffb9ae94cbbbf7a6b2eab5a72cec66deb607040b184c217a124b77ac06ac414d77ec86d6d62198f0fb425119657ca460403d509

data/CHANGELOG.md

@@ -1,3 +1,18 @@
+0.13.0
+------
+
+* Serve Vite-based applications from Vite's development server in
+  `development`, so that changes are hot-reloaded instead of requiring a
+  restart. Configure it with the `dev_server` option, or opt out with
+  `dev_server: false`
+* Require `ember-cli-rails-assets >= 0.9.0`, which serves the
+  `include_ember_script_tags` startup tags from Vite's development server
+  when the application is served from it
+* Add an `origin` option to `dev_server`, separating the origin the browser
+  loads assets from, from the address the development server binds to — for
+  containers, where the server must bind to `0.0.0.0` but browsers refuse
+  that address as an origin
+
 0.13.0.beta1
 ------
 

data/README.md

@@ -81,6 +81,10 @@ c.app :frontend, path: "~/projects/my-ember-app"
 
 - `yarn` - enables the [yarn](https://github.com/yarnpkg/yarn) package manager when installing dependencies
 
+- `dev_server` - configures [Vite's development server](#vite-based-applications)
+  for Vite-based applications in `development`. Pass `false` to opt out of it,
+  or a Hash of `host`, `port`, and `timeout` settings.
+
 ```ruby
 EmberCli.configure do |c|
   c.app :adminpanel # path defaults to `Rails.root.join("adminpanel")`
@@ -176,16 +180,83 @@ suites, configure the `default` task to depend on both `spec` and `ember:test`.
 task default: [:spec, "ember:test"]
 ```
 
-**Vite-based applications**
+### Vite-based applications
 
 When Rails is running in development mode, classic (Broccoli-based) Ember
 applications are built with `ember build --watch`, so changes to the Ember
 application are picked up automatically.
 
-Vite-based Ember applications (generated with `ember-cli >= 6.8`) are instead
-built once, synchronously, when they are first requested. To pick up changes
-to the Ember application, restart the Rails server, or iterate on the Ember
-application directly with its own development server (`npm start`).
+Vite-based Ember applications (generated with `ember-cli >= 6.8`) are served by
+Vite's own development server instead — the same one the application's
+`npm start` script runs. `ember-cli-rails` starts it on the first request,
+waits for it to accept connections, and shuts it down when Rails exits.
+
+Rails still renders the application's `index.html`, but reads it from the
+development server rather than from disk. The root-relative URLs in that
+document are rewritten to point at the development server, so the browser
+loads the application's modules — and Vite's HMR client — from it directly.
+Changes to the Ember application are hot-reloaded without reloading the page,
+and without restarting Rails.
+
+Assets that the Ember application references relatively (an `<img>` in a
+template, for instance) are still requested from Rails, which proxies them to
+the development server.
+
+**Configuring the development server**
+
+By default the development server listens on an available port on `127.0.0.1`,
+and `ember-cli-rails` waits up to 30 seconds for it to start:
+
+```rb
+EmberCli.configure do |c|
+  c.app :frontend, dev_server: { host: "127.0.0.1", port: 4200, timeout: 60 }
+end
+```
+
+If something is already listening on the configured `host` and `port`,
+`ember-cli-rails` uses it instead of starting a second server. That makes it
+possible to run `npm start` yourself, on a port the initializer names, and have
+Rails serve the application from it.
+
+`host` is both the address the development server binds to and — together with
+`port` — the origin the browser loads the application's modules from. When the
+two differ, configure the browser-facing origin separately with `origin`. The
+typical case is Rails running in a container: the development server must bind
+to `0.0.0.0` to be reachable through the container's published port, but
+browsers refuse to connect to `http://0.0.0.0`:
+
+```rb
+EmberCli.configure do |c|
+  c.app :frontend, dev_server: {
+    host: "0.0.0.0",
+    port: 4200,
+    origin: "http://localhost:4200",
+  }
+end
+```
+
+With `host: "0.0.0.0"`, Rails itself reaches the development server through the
+loopback interface.
+
+The development server's output is written to
+`log/ember-<app>.<environment>.log`.
+
+**Opting out**
+
+To build the application once, synchronously, on the first request instead of
+running a development server, disable it:
+
+```rb
+EmberCli.configure do |c|
+  c.app :frontend, dev_server: false
+end
+```
+
+Changes to the Ember application are then only picked up by restarting the
+Rails server.
+
+The development server is only used in `development`. `test` and `production`
+are served from the output of `ember build`, as they always have been.
 
 ## Deploy
 
@@ -472,6 +543,17 @@ and `modulepreload` links, and the ES module script tags — extracted from
 the generated `index.html`. `include_ember_stylesheet_tags` only supports
 classic (Broccoli-based) applications.
 
+When the application is served by [Vite's development
+server](#vite-based-applications), `include_ember_script_tags` (from
+[ember-cli-rails-assets]) reads `index.html` from the server and emits the
+startup tags with absolute URLs pointing at it — nothing is built, and changes
+to the application are picked up by reloading the page.
+
+With the development server disabled (`dev_server: false`), the helpers read
+the output of `ember build` instead: the application is built once,
+synchronously, on the first request, and changes to it are only picked up by
+restarting the Rails server.
+
 Following the example above, configure the mounted EmberCLI application to be
 served by a custom controller (`ApplicationController`, in this case).
 
@@ -627,6 +709,11 @@ make sure it's configured to run a single worker process.
 Without restricting the server to a single process, [it is possible for multiple
 EmberCLI runners to clobber each others' work][#94].
 
+This does not apply to Vite-based applications served by [Vite's development
+server](#vite-based-applications): nothing is written to a shared build
+directory. Give the application a fixed `port` so that the workers share a
+single development server rather than starting one each.
+
 [Puma]: https://github.com/puma/puma
 [Unicorn]: https://rubygems.org/gems/unicorn
 [#94]: https://github.com/tricknotes/ember-cli-rails/issues/94#issuecomment-77627453
@@ -689,8 +776,11 @@ Note the following limitations for Vite-based applications:
 * `include_ember_script_tags` emits the full set of tags the application
   needs to boot, stylesheets included; `include_ember_stylesheet_tags` is
   classic-only and must not be called for Vite-based applications
-* in development, the application is built synchronously on first request
-  instead of being rebuilt on file changes
+* in development, the application is served by [Vite's development
+  server](#vite-based-applications) rather than out of a build directory. The
+  asset helpers serve their tags from the development server too; with
+  `dev_server: false` they read the build output, which is built once,
+  synchronously, on the first request
 
 ## Ruby and Rails support
 

data/lib/ember_cli/app.rb

@@ -2,7 +2,9 @@ require "html_page/renderer"
 require "ember_cli/path_set"
 require "ember_cli/shell"
 require "ember_cli/build_monitor"
+require "ember_cli/deploy/dev_server"
 require "ember_cli/deploy/file"
+require "ember_cli/dev_server"
 
 module EmberCli
   class App
@@ -49,20 +51,15 @@ module EmberCli
 
     def build
       unless EmberCli.skip?
-        if development?
-          if paths.vite?
-            # The Vite-based blueprint (`ember-cli >= 6.8`) has no
-            # `ember-cli-rails-addon` to manage the build lock, so build
-            # synchronously instead of watching for changes.
-            compile
-          else
-            build_and_watch
-          end
-        elsif test?
-          compile
+        if dev_server?
+          # Vite's own development server rebuilds and hot-reloads the
+          # application, so there is nothing to build ahead of time.
+          dev_server.start
+        else
+          build_for_environment
+
+          @build.wait!
         end
-
-        @build.wait!
       end
     end
 
@@ -106,6 +103,24 @@ module EmberCli
       deploy.to_rack
     end
 
+    def dev_server
+      @dev_server ||= DevServer.new(
+        name: name,
+        paths: paths,
+        shell: @shell,
+        options: dev_server_options,
+      )
+    end
+
+    # Whether this application is served by Vite's development server rather
+    # than out of the directory `ember build` writes to.
+    def dev_server?
+      strategy = deploy_strategy
+
+      strategy.is_a?(Class) &&
+        strategy.ancestors.include?(EmberCli::Deploy::DevServer)
+    end
+
     private
 
     def development?
@@ -124,12 +139,38 @@ module EmberCli
       strategy = options.fetch(:deploy, {})
 
       if strategy.respond_to?(:fetch)
-        strategy.fetch(rails_env, EmberCli::Deploy::File)
+        strategy.fetch(rails_env) { default_deploy_strategy }
       else
         strategy
       end
     end
 
+    def default_deploy_strategy
+      if development? && paths.vite? && dev_server_enabled?
+        EmberCli::Deploy::DevServer
+      else
+        EmberCli::Deploy::File
+      end
+    end
+
+    def dev_server_option
+      options.fetch(:dev_server, true)
+    end
+
+    def dev_server_enabled?
+      dev_server_option != false
+    end
+
+    def dev_server_options
+      option = dev_server_option
+
+      if option.respond_to?(:fetch)
+        option
+      else
+        {}
+      end
+    end
+
     def rails_env
       Rails.env.to_s.to_sym
     end
@@ -138,6 +179,21 @@ module EmberCli
       EmberCli.env
     end
 
+    def build_for_environment
+      if development?
+        if paths.vite?
+          # The Vite-based blueprint (`ember-cli >= 6.8`) has no
+          # `ember-cli-rails-addon` to manage the build lock, so build
+          # synchronously instead of watching for changes.
+          compile
+        else
+          build_and_watch
+        end
+      elsif test?
+        compile
+      end
+    end
+
     def build_and_watch
       prepare
       @shell.build_and_watch

data/lib/ember_cli/command.rb

@@ -17,6 +17,20 @@ module EmberCli
       ember_build(watch: watch)
     end
 
+    # Boots Vite's development server for an application generated with the
+    # Vite-based blueprint (`ember-cli >= 6.8`). This is what the blueprint's
+    # own `npm start` script runs.
+    def dev_server(host:, port:)
+      line = Terrapin::CommandLine.new(paths.vite, [
+        "--host :host",
+        "--port :port",
+        "--strictPort",
+        "--clearScreen false",
+      ].join(" "))
+
+      line.command(host: host.to_s, port: port.to_s)
+    end
+
     private
 
     attr_reader :options, :paths

data/lib/ember_cli/deploy/dev_server.rb

@@ -0,0 +1,47 @@
+require "ember_cli/dev_server_proxy"
+require "ember_cli/errors"
+
+module EmberCli
+  module Deploy
+    # Serves an Ember application from its Vite development server instead of
+    # from the `dist` directory written by `ember build`.
+    #
+    # The `index.html` served by the development server refers to its assets
+    # (`/@vite/client` included) with root-relative URLs. Rails serves the
+    # document from its own origin, so those URLs are rewritten to absolute
+    # URLs pointing at the development server. Loading them from there means
+    # the Vite client opens its HMR WebSocket against the development server
+    # directly, without Rails proxying it.
+    class DevServer
+      ROOT_RELATIVE_URL = %r{(\s)(src|href)=(["'])/(?!/)}i
+
+      def initialize(app)
+        @app = app
+      end
+
+      def mountable?
+        true
+      end
+
+      def to_rack
+        DevServerProxy.new(app)
+      end
+
+      def index_html
+        rewrite_root_relative_urls(dev_server.index_html)
+      end
+
+      private
+
+      attr_reader :app
+
+      delegate :dev_server, to: :app
+
+      def rewrite_root_relative_urls(html)
+        html.gsub(ROOT_RELATIVE_URL) do
+          "#{$1}#{$2}=#{$3}#{dev_server.origin}/"
+        end
+      end
+    end
+  end
+end

data/lib/ember_cli/dev_server.rb

@@ -0,0 +1,187 @@
+require "monitor"
+require "net/http"
+require "socket"
+require "uri"
+
+require "ember_cli/errors"
+
+module EmberCli
+  # Manages the Vite development server backing a single Ember application.
+  #
+  # The server is booted lazily, and the Ember application's `index.html` and
+  # assets are read from it over HTTP instead of from the `dist` directory
+  # written by `ember build`.
+  class DevServer
+    DEFAULT_HOST = "127.0.0.1".freeze
+    DEFAULT_TIMEOUT = 30
+    POLL_INTERVAL = 0.1
+    CONNECT_TIMEOUT = 1
+
+    def initialize(name:, paths:, shell:, options: {})
+      @name = name
+      @paths = paths
+      @shell = shell
+      @options = options.respond_to?(:fetch) ? options : {}
+      @monitor = Monitor.new
+    end
+
+    def host
+      @host ||= option(:host) { DEFAULT_HOST }.to_s
+    end
+
+    def port
+      @port ||= option(:port) { available_port }.to_i
+    end
+
+    def timeout
+      @timeout ||= option(:timeout) { DEFAULT_TIMEOUT }.to_f
+    end
+
+    # The origin the browser loads the application's assets from. It defaults
+    # to the address the development server binds to, but can be configured
+    # separately for setups where the two differ — a development server bound
+    # to `0.0.0.0` inside a container, reached by the browser through a
+    # published port, for instance.
+    def origin
+      @origin ||= option(:origin) { "http://#{host}:#{port}" }.to_s.chomp("/")
+    end
+
+    # Boots the development server unless something is already listening on
+    # its address, and blocks until it accepts connections.
+    def start
+      return true if listening?
+
+      # Requests are served concurrently, so make sure only one of them boots
+      # the development server.
+      monitor.synchronize do
+        return true if listening?
+
+        shell.start_dev_server(host: host, port: port)
+
+        wait_until_listening!
+      end
+    end
+
+    def index_html
+      response = get("/")
+
+      unless response.is_a?(Net::HTTPSuccess)
+        fail BuildError.new(<<~MSG)
+          #{name.inspect} failed to serve an `index.html` file.
+
+          #{origin}/ responded with #{response.code} #{response.message}:
+
+          #{response.body}
+        MSG
+      end
+
+      response.body.to_s
+    end
+
+    def get(path, headers = {})
+      request(Net::HTTP::Get, path, headers)
+    end
+
+    def head(path, headers = {})
+      request(Net::HTTP::Head, path, headers)
+    end
+
+    def options_request(path, headers = {})
+      request(Net::HTTP::Options, path, headers)
+    end
+
+    private
+
+    attr_reader :monitor, :name, :options, :paths, :shell
+
+    def option(key)
+      options.fetch(key) { options.fetch(key.to_s) { yield } }
+    end
+
+    def request(request_class, path, headers)
+      start
+
+      uri = URI.join("http://#{connect_host}:#{port}", path)
+      # Pass `nil` as the proxy address so that a `http_proxy` environment
+      # variable never routes requests for the local server through a proxy.
+      Net::HTTP.start(uri.hostname, uri.port, nil, read_timeout: timeout) do |http|
+        http.request(request_class.new(uri, headers))
+      end
+    rescue SystemCallError, IOError, Timeout::Error => error
+      fail BuildError.new(<<~MSG)
+        #{name.inspect} could not reach its development server at #{origin}.
+
+        #{error.class}: #{error.message}
+
+        Its output is written to #{paths.log}.
+      MSG
+    end
+
+    # The address Rails connects to the development server on. `0.0.0.0` asks
+    # the server to listen on every interface, but is not an address to
+    # connect to, so requests go to the loopback interface instead.
+    def connect_host
+      if host == "0.0.0.0"
+        "127.0.0.1"
+      else
+        host
+      end
+    end
+
+    def listening?
+      Socket.tcp(connect_host, port, connect_timeout: CONNECT_TIMEOUT, &:close)
+
+      true
+    rescue SystemCallError, IOError
+      false
+    end
+
+    def wait_until_listening!
+      deadline = now + timeout
+
+      loop do
+        return true if listening?
+
+        unless shell.dev_server_running?
+          fail BuildError.new(<<~MSG)
+            #{name.inspect} failed to start its development server on #{origin}.
+
+            Its output is written to #{paths.log}.
+          MSG
+        end
+
+        if now >= deadline
+          fail BuildError.new(<<~MSG)
+            #{name.inspect} timed out after #{timeout.round} seconds waiting for
+            its development server to listen on #{origin}.
+
+            Its output is written to #{paths.log}.
+
+            Configure a longer timeout with:
+
+                EmberCli.configure do |config|
+                  config.app #{name.to_sym.inspect}, dev_server: { timeout: 60 }
+                end
+
+          MSG
+        end
+
+        sleep POLL_INTERVAL
+      end
+    end
+
+    def now
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+
+    def available_port
+      server = TCPServer.new(host, 0)
+
+      begin
+        server.addr[1]
+      ensure
+        server.close
+      end
+    end
+  end
+end

data/lib/ember_cli/dev_server_proxy.rb

@@ -0,0 +1,103 @@
+require "rack"
+
+module EmberCli
+  # Forwards requests made to an Ember application's mount point to its Vite
+  # development server.
+  #
+  # Assets referenced by the Ember application itself (rather than by its
+  # `index.html`) are resolved against the document's URL, so they are
+  # requested from Rails. Proxying them keeps those references working the
+  # same way they do when the application is served out of `dist`.
+  class DevServerProxy
+    ALLOWED_VERBS = %w[GET HEAD OPTIONS].freeze
+    # Hop-by-hop headers, plus the `Content-Encoding` header describing a body
+    # that `Net::HTTP` may have decoded already.
+    SKIPPED_HEADERS = %w[
+      connection
+      content-encoding
+      keep-alive
+      proxy-authenticate
+      proxy-authorization
+      te
+      trailer
+      transfer-encoding
+      upgrade
+    ].freeze
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      request = Rack::Request.new(env)
+
+      unless ALLOWED_VERBS.include?(request.request_method)
+        return method_not_allowed
+      end
+
+      rack_response(proxy(request))
+    end
+
+    private
+
+    attr_reader :app
+
+    delegate :dev_server, to: :app
+
+    def proxy(request)
+      path = path_for(request)
+      headers = { "accept-encoding" => "identity" }
+
+      case request.request_method
+      when "HEAD" then dev_server.head(path, headers)
+      when "OPTIONS" then dev_server.options_request(path, headers)
+      else dev_server.get(path, headers)
+      end
+    end
+
+    def path_for(request)
+      path = request.path_info.presence || "/"
+      query = request.query_string
+
+      if query.present?
+        "#{path}?#{query}"
+      else
+        path
+      end
+    end
+
+    def rack_response(response)
+      body = response.body.to_s
+
+      [response.code.to_i, response_headers(response, body), [body]]
+    end
+
+    def response_headers(response, body)
+      headers = {}
+
+      response.each_header do |name, value|
+        unless SKIPPED_HEADERS.include?(name.downcase)
+          headers[name.downcase] = value
+        end
+      end
+
+      headers["content-length"] ||= body.bytesize.to_s
+
+      headers
+    end
+
+    def method_not_allowed
+      body = "Method Not Allowed"
+
+      [
+        405,
+        {
+          "allow" => ALLOWED_VERBS.join(", "),
+          "content-type" => "text/plain",
+          "content-length" => body.bytesize.to_s,
+        },
+        [body],
+      ]
+    end
+  end
+end

data/lib/ember_cli/path_set.rb

@@ -64,6 +64,24 @@ module EmberCli
       end
     end
 
+    def vite
+      @vite ||= begin
+        root.join("node_modules", ".bin", "vite").tap do |path|
+          unless path.executable?
+            fail DependencyError.new <<-MSG.strip_heredoc
+              No `vite` executable found for `#{app_name}`.
+
+              Install it:
+
+                  $ cd #{root}
+                  $ #{package_manager} install
+
+            MSG
+          end
+        end
+      end
+    end
+
     def lockfile
       @lockfile ||= tmp.join("build.lock")
     end

data/lib/ember_cli/shell.rb

@@ -20,16 +20,44 @@ module EmberCli
     def build_and_watch
       unless running?
         lock_buildfile
-        self.pid = spawn ember.build(watch: true)
+        self.pid = spawn(
+          ember.build(watch: true),
+          err: paths.build_error_file.to_s,
+        )
         detach
       end
     end
 
+    def start_dev_server(host:, port:)
+      unless dev_server_running?
+        # Run the development server in its own process group so that the
+        # whole tree can be signaled when Rails exits.
+        self.dev_server_pid = spawn(
+          ember.dev_server(host: host, port: port),
+          out: [paths.log.to_s, "a"],
+          err: [:child, :out],
+          pgroup: true,
+        )
+        Process.detach(dev_server_pid)
+      end
+
+      dev_server_pid
+    end
+
+    def dev_server_running?
+      process_running?(dev_server_pid)
+    end
+
     def stop
       if pid.present?
-        Process.kill(:INT, pid)
+        signal(pid)
         self.pid = nil
       end
+
+      if dev_server_pid.present?
+        signal(-dev_server_pid)
+        self.dev_server_pid = nil
+      end
     end
 
     def install
@@ -58,7 +86,7 @@ module EmberCli
 
     private
 
-    attr_accessor :pid
+    attr_accessor :dev_server_pid, :pid
     attr_reader :ember, :env, :options, :paths
 
     delegate :run, :run!, to: :runner
@@ -80,15 +108,21 @@ module EmberCli
       ].select(&:exist?)
     end
 
-    def spawn(command)
+    def spawn(command, **redirects)
       Kernel.spawn(
         env,
         command,
         chdir: paths.root.to_s,
-        err: paths.build_error_file.to_s,
+        **redirects,
       ) || exit(1)
     end
 
+    def signal(process_id)
+      Process.kill(:INT, process_id)
+    rescue Errno::ESRCH, Errno::EPERM
+      nil
+    end
+
     def runner
       Runner.new(
         options: { chdir: paths.root.to_s },
@@ -99,7 +133,11 @@ module EmberCli
     end
 
     def running?
-      pid.present? && Process.getpgid(pid)
+      process_running?(pid)
+    end
+
+    def process_running?(process_id)
+      process_id.present? && !!Process.getpgid(process_id)
     rescue Errno::ESRCH
       false
     end

data/lib/ember_cli/version.rb

@@ -1,3 +1,3 @@
 module EmberCli
-  VERSION = "0.13.0.beta1".freeze
+  VERSION = "0.13.0".freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ember-cli-rails
 version: !ruby/object:Gem::Version
-  version: 0.13.0.beta1
+  version: 0.13.0
 platform: ruby
 authors:
 - Pavel Pravosud
@@ -18,7 +18,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.8.0
+        version: 0.9.0
     - - "<"
       - !ruby/object:Gem::Version
         version: '1.0'
@@ -28,7 +28,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.8.0
+        version: 0.9.0
     - - "<"
       - !ruby/object:Gem::Version
         version: '1.0'
@@ -117,7 +117,7 @@ dependencies:
         version: 3.6.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: '7.0'
+        version: '9.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -127,7 +127,7 @@ dependencies:
         version: 3.6.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: '7.0'
+        version: '9.0'
 - !ruby/object:Gem::Dependency
   name: capybara-selenium
   requirement: !ruby/object:Gem::Requirement
@@ -177,7 +177,10 @@ files:
 - lib/ember_cli/build_monitor.rb
 - lib/ember_cli/command.rb
 - lib/ember_cli/configuration.rb
+- lib/ember_cli/deploy/dev_server.rb
 - lib/ember_cli/deploy/file.rb
+- lib/ember_cli/dev_server.rb
+- lib/ember_cli/dev_server_proxy.rb
 - lib/ember_cli/ember_constraint.rb
 - lib/ember_cli/engine.rb
 - lib/ember_cli/errors.rb
@@ -214,7 +217,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.16
+rubygems_version: 4.0.20
 specification_version: 4
 summary: Integration between Ember CLI and Rails
 test_files: []