anycable-rails-core 1.5.3 → 1.6.2

data/lib/generators/anycable/setup/setup_generator.rb

@@ -9,11 +9,11 @@ module AnyCableRailsGenerators
     source_root File.expand_path("templates", __dir__)
 
     DOCS_ROOT = "https://docs.anycable.io"
-    DEVELOPMENT_METHODS = %w[skip local docker].freeze
-    DEPLOYMENT_METHODS = %w[other fly heroku anycable_plus].freeze
+    DEVELOPMENT_METHODS = %w[skip bin docker].freeze
+    DEPLOYMENT_METHODS = %w[skip thruster fly heroku anycable_plus].freeze
     RPC_IMPL = %w[none grpc http].freeze
 
-    class_option :devenv,
+    class_option :development,
       type: :string,
       desc: "Select your development environment (options: #{DEVELOPMENT_METHODS.reverse.join(", ")})"
     class_option :rpc,
@@ -31,37 +31,85 @@ module AnyCableRailsGenerators
       say ""
       say "👋 Welcome to AnyCable interactive installer. We'll guide you through the process of installing AnyCable for your Rails application. Buckle up!"
       say ""
+      @todos = []
     end
 
     def rpc_implementation
-      say "AnyCable connects to your Rails server to communicate with Action Cable channels (via RPC API). Learn more from the docs 👉 #{DOCS_ROOT}/anycable-go/rpc"
-      say ""
+      if RPC_IMPL.include?(options[:rpc])
+        @rpc_impl = options[:rpc]
+        return
+      end
+
+      if hotwire? && !custom_channels?
+        say_status :info, <<~MSG
+          ⚡️ Hotwire application has been detected, installing AnyCable in a standalone mode.
+        MSG
+        @rpc_impl = "none"
+        return
+      end
+
+      if custom_channels?
+        answer = RPC_IMPL.index(options[:rpc]) || 99
+
+        unless RPC_IMPL[answer.to_i]
+          say ""
+          say <<~MSG
+            AnyCable connects to your Rails server to communicate with Action Cable channels either via HTTP or gRPC.
+
+            gRPC provides better performance and scalability but requires running
+            a separate component (a gRPC server).
 
-      answer = RPC_IMPL.index(options[:rpc]) || 99
+            HTTP is a good option for a quick start or in case your deployment platform doesn't
+            support running multiple web services (e.g., Heroku).
 
-      until RPC_IMPL[answer.to_i]
-        answer = ask "Do you want to use gRPC or HTTP for AnyCable RPC? (1) gRPC, (2) HTTP, (0) None"
+            If you only use Action Cable for Turbo Streams, you don't need RPC at all.
+
+            Learn more from the docs 👉 #{DOCS_ROOT}/anycable-go/rpc
+          MSG
+          say ""
+        end
+
+        answer = ask "Which RPC implementation would you like to use?", limited_to: %w[grpc http none], default: "grpc"
+
+        @rpc_impl = answer
+        return
       end
 
-      @rpc_impl = RPC_IMPL[answer.to_i]
+      # no Hotwire, no custom channels
+      say_status :info, "Looks like you don't have any real-time functionality yet. Let's start with a miminal AnyCable setup!"
+      @rpc_impl = "none"
     end
 
     def development_method
-      answer = DEVELOPMENT_METHODS.index(options[:devenv]) || 99
-
-      say ""
+      if DEVELOPMENT_METHODS.include?(options[:development])
+        @development = options[:development]
+      end
 
-      until DEVELOPMENT_METHODS[answer.to_i]
-        answer = ask "Do you want to run AnyCable server (anycable-go) locally or as a Docker container? (1) Local, (2) Docker, (0) Skip"
+      # Fast-track for local development
+      if file_exists?("bin/dev") && file_exists?("Procfile.dev")
+        @development = "bin"
       end
 
-      @devenv = DEVELOPMENT_METHODS[answer.to_i]
+      unless @development
+        say ""
+        say <<~MSG
+          You can run AnyCable server locally (recommended for most cases) or as a Docker container (in case you develop in a containerized environment).
+
+          For a local installation, we provide a convenient binstub (`bin/anycable-go`) which automatically
+          installs AnyCable server for the current platform.
+        MSG
+        say ""
+
+        answer = ask "Which way to run AnyCable server locally would you prefer?", limited_to: %w[bin docker skip], default: "bin"
 
-      case @devenv
+        @development = answer
+      end
+
+      case @development
       when "skip"
-        say_status :help, "⚠️  Please, read this guide on how to install AnyCable server 👉 #{DOCS_ROOT}/anycable-go/getting_started", :yellow
+        @todos << "Install AnyCable server for local development: #{DOCS_ROOT}/anycable-go/getting_started"
       else
-        send "install_for_#{@devenv}"
+        send "install_for_#{@development}"
       end
     end
 
@@ -70,6 +118,8 @@ module AnyCableRailsGenerators
         template "anycable.yml"
       end
 
+      template "anycable.toml"
+
       update_cable_yml
     end
 
@@ -78,22 +128,112 @@ module AnyCableRailsGenerators
 
       say_status :info, "🤖 Running static compatibility checks with RuboCop"
       res = run "bundle exec rubocop -r 'anycable/rails/compatibility/rubocop' --only AnyCable/InstanceVars,AnyCable/PeriodicalTimers,AnyCable/InstanceVars"
-      say_status :help, "⚠️  Please, take a look at the icompatibilities above and fix them. See #{DOCS_ROOT}/rails/compatibility" unless res
+
+      unless res
+        say_status :help, "⚠️  Please, take a look at the incompatibilities above and fix them"
+
+        @todos << "Fix Action Cable compatibility issues (listed above): #{DOCS_ROOT}/rails/compatibility"
+      end
     end
 
     def cable_url_info
-      say_status :help, "⚠️  If you're using JS client make sure you have " \
-                        "`action_cable_meta_tag` or `action_cable_with_jwt_meta_tag` included in your HTML layout"
+      meta_tag = norpc? ? "action_cable_with_jwt_meta_tag" : "action_cable_meta_tag"
+
+      begin
+        app_layout = nil
+        inside("app/views/layouts") do
+          next unless File.file?("application.html.erb")
+          app_layout = File.read("application.html.erb")
+        end
+        return if app_layout&.include?(meta_tag)
+
+        if norpc? && app_layout&.include?("action_cable_meta_tag")
+          gsub_file "app/views/layouts/application.html.erb", %r{^\s+<%= action_cable_meta_tag %>.*$} do |match|
+            match.sub("action_cable_meta_tag", "action_cable_with_jwt_meta_tag")
+          end
+          inform_jwt_identifiers("app/views/layouts/application.html.erb")
+          return
+        end
+
+        found = false
+        gsub_file "app/views/layouts/application.html.erb", %r{^\s+<%= csp_meta_tag %>.*$} do |match|
+          found = true
+          match << "\n    <%= #{meta_tag} %>"
+        end
+        if found
+          inform_jwt_identifiers("app/views/layouts/application.html.erb") if norpc?
+          return
+        end
+      rescue Errno::ENOENT
+      end
+
+      @todos << "⚠️  Ensure you have `action_cable_meta_tag`\n" \
+        "      or `action_cable_with_jwt_meta_tag` included in your HTML layout:\n" \
+        "      👉 https://docs.anycable.io/rails/getting_started"
     end
 
-    def deployment_method
-      say_status :info, "🚢  See our deployment guide to learn how to run AnyCable in production 👉 #{DOCS_ROOT}/deployment"
+    def action_cable_engine
+      return unless application_rb
+      return if application_rb.match?(/^require\s+['"](action_cable\/engine|rails\/all)['"]/)
+
+      found = false
+      gsub_file "config/application.rb", %r{^require ['"]rails['"].*$} do |match|
+        found = true
+        match << %(\nrequire "action_cable/engine")
+      end
 
-      say_status :info, "Check out AnyCable+, our hosted AnyCable solution: https://plus.anycable.io"
+      return if found
+
+      @todos << "⚠️  Ensure Action Cable is loaded. Add `require \"action_cable/engine\"` to your `config/application.rb` file"
+    end
+
+    def anycable_client
+      if hotwire? && install_js_packages
+        gsub_file "app/javascript/application.js", /^import "@hotwired\/turbo-rails".*$/, <<~JS
+          import "@hotwired/turbo"
+          import { createCable } from "@anycable/web"
+          import { start } from "@anycable/turbo-stream"
+
+          // Use extended Action Cable protocol to support reliable streams and presence
+          // See https://github.com/anycable/anycable-client
+          const cable = createCable({ protocol: 'actioncable-v1-ext-json' })
+          // Prevent frequent resubscriptions during morphing or navigation
+          start(cable, { delayedUnsubscribe: true })
+        JS
+        return
+      end
+
+      @todos << "⚠️  Install AnyCable JS client to use advanced features (presence, reliable streams): 👉 https://github.com/anycable/anycable-client\n"
+    end
+
+    def turbo_verifier_key
+      return unless hotwire?
+      return if application_rb.include?("config.turbo.signed_stream_verifier_key = AnyCable.config.secret")
+
+      gsub_file "config/application.rb", %r{\s+end\nend} do |match|
+        "\n\n" \
+        "    # Use AnyCable secret to sign Turbo Streams\n" \
+        "    # #{DOCS_ROOT}/guides/hotwire?id=rails-applications\n" \
+        "    config.turbo.signed_stream_verifier_key = AnyCable.config.secret#{match}"
+      end
+    end
+
+    def deployment_method
+      @todos << "🚢 Learn how to run AnyCable in production: 👉 #{DOCS_ROOT}/deployment\n" \
+        "      For the quick start, consider using AnyCable+ (https://plus.anycable.io)\n" \
+        "      or AnyCable Thruster (https://github.com/anycable/thruster)"
     end
 
     def finish
-      say_status :info, "✅ AnyCable has been configured successfully!"
+      say_status :info, "✅ AnyCable has been configured"
+
+      if @todos.any?
+        say ""
+        say "📋 Please, check the following actions required to complete the setup:\n"
+        @todos.each do |todo|
+          say "- [ ] #{todo}"
+        end
+      end
     end
 
     private
@@ -115,7 +255,7 @@ module AnyCableRailsGenerators
     end
 
     def local?
-      @devenv == "local"
+      @development == "local"
     end
 
     def grpc?
@@ -126,6 +266,26 @@ module AnyCableRailsGenerators
       @rpc_impl == "http"
     end
 
+    def norpc?
+      @rpc_impl == "none"
+    end
+
+    def hotwire?
+      !!gemfile_lock&.match?(/^\s+turbo-rails\b/) &&
+        application_js&.match?(/^import\s+"@hotwired\/turbo/)
+    end
+
+    def custom_channels?
+      @has_custom_channels ||= begin
+        res = nil
+        in_root do
+          next unless File.directory?("app/channels")
+          res = Dir["app/channels/*_channel.rb"].any?
+        end
+        res
+      end
+    end
+
     def gemfile_lock
       @gemfile_lock ||= begin
         res = nil
@@ -137,6 +297,28 @@ module AnyCableRailsGenerators
       end
     end
 
+    def application_rb
+      @application_rb ||= begin
+        res = nil
+        in_root do
+          next unless File.file?("config/application.rb")
+          res = File.read("config/application.rb")
+        end
+        res
+      end
+    end
+
+    def application_js
+      @application_js ||= begin
+        res = nil
+        in_root do
+          next unless File.file?("app/javascript/application.js")
+          res = File.read("app/javascript/application.js")
+        end
+        res
+      end
+    end
+
     def install_for_docker
       say_status :help, "️️⚠️  Docker development configuration could vary", :yellow
 
@@ -159,7 +341,7 @@ module AnyCableRailsGenerators
                 condition: service_started
 
           ws:
-            image: anycable/anycable-go:1.5
+            image: anycable/anycable-go:1.6
             ports:
               - '8080:8080'
               - '8090'
@@ -168,6 +350,7 @@ module AnyCableRailsGenerators
               ANYCABLE_BROADCAST_ADAPTER: http
               ANYCABLE_RPC_HOST: anycable:50051
               ANYCABLE_DEBUG: ${ANYCABLE_DEBUG:-true}
+              ANYCABLE_SECRET: "anycable-local-secret"
 
           anycable:
             <<: *rails
@@ -208,16 +391,18 @@ module AnyCableRailsGenerators
               ANYCABLE_BROADCAST_ADAPTER: http
               ANYCABLE_RPC_HOST: http://rails:3000/_anycable
               ANYCABLE_DEBUG: ${ANYCABLE_DEBUG:-true}
+              ANYCABLE_SECRET: "anycable-local-secret"
           ─────────────────────────────────────────
         YML
       end
     end
 
-    def install_for_local
+    def install_for_bin
       unless file_exists?("bin/anycable-go")
         generate "anycable:bin", "--version #{options[:version]}"
       end
       template_proc_files
+      update_bin_dev
       true
     end
 
@@ -230,7 +415,23 @@ module AnyCableRailsGenerators
             adapter = Regexp.last_match[1]
             next match if adapter == "test" || adapter.include?("any_cable")
 
-            match.sub(adapter, %(<%= ENV.fetch("ACTION_CABLE_ADAPTER", "any_cable") %>))
+            match.sub(adapter, "any_cable")
+          end
+
+          # Try removing all lines contaning options for previous adapters,
+          # only keep aliases (<<:*), adapter and channel_prefix options.
+          new_clean_contents = new_contents.lines.select do |line|
+            line.match?(/^(\S|\s+adapter:|\s+channel_prefix:|\s+<<:)/) || line.match?(/^\s*$/)
+          end.join
+
+          # Verify new config
+          begin
+            clean_config = YAML.safe_load(new_clean_contents, aliases: true).deep_symbolize_keys
+            orig_config = YAML.safe_load(contents, aliases: true).deep_symbolize_keys
+
+            new_contents = new_clean_contents if clean_config.keys == orig_config.keys
+          rescue => _e
+            # something went wrong, keep older options
           end
 
           File.write "config/cable.yml", new_contents
@@ -248,8 +449,6 @@ module AnyCableRailsGenerators
       if file_exists?(file_name)
         update_procfile(file_name)
       else
-        say_status :help, "💡 We recommend using Overmind to manage multiple processes in development 👉 https://github.com/DarthSim/overmind", :yellow
-
         return if options[:skip_procfile_dev]
 
         template file_name
@@ -260,22 +459,38 @@ module AnyCableRailsGenerators
       in_root do
         contents = File.read(file_name)
 
-        unless http_rpc?
+        if grpc?
           unless contents.match?(/^anycable:\s/)
             append_file file_name, "anycable: bundle exec anycable\n", force: true
           end
         end
         unless contents.match?(/^ws:\s/)
-          append_file file_name, "ws: bin/anycable-go #{anycable_go_options}", force: true
+          append_file file_name, "ws: bin/anycable-go --port 8080", force: true
         end
       end
     end
 
-    def anycable_go_options
-      opts = ["--port=8080"]
-      opts << "--broadcast_adapter=http" unless redis?
-      opts << "--rpc_host=http://localhost:3000/_anycable" if http_rpc?
-      opts.join(" ")
+    def update_bin_dev
+      unless file_exists?("bin/dev")
+        template "bin/dev"
+        chmod "bin/dev", 0755, verbose: false # rubocop:disable Style/NumericLiteralPrefix
+
+        @todos << "Now you should use bin/dev to run your application with AnyCable services"
+        return
+      end
+
+      in_root do
+        contents = File.read("bin/dev")
+
+        return if contents.include?("Procfile.dev")
+
+        if contents.include?(%(exec "./bin/rails"))
+          template "bin/dev", force: true
+          chmod "bin/dev", 0755, verbose: false # rubocop:disable Style/NumericLiteralPrefix
+        else
+          @todos << "Please, check your bin/dev file and ensure it runs Procfile.dev with AnyCable services"
+        end
+      end
     end
 
     def file_exists?(name)
@@ -283,5 +498,32 @@ module AnyCableRailsGenerators
         return File.file?(name)
       end
     end
+
+    def inform_jwt_identifiers(path)
+      return unless file_exists?("app/channels/application_cable/connection.rb")
+
+      in_root do
+        contents = File.read("app/channels/application_cable/connection.rb")
+
+        if contents.match?(%r{^\s+identified_by\s})
+          @todos << "⚠️  Please, provide the correct connection identifiers to the #action_cable_with_jwt_meta_tag in #{path}. Read more: 👉 #{DOCS_ROOT}/rails/authentication?id=jwt-authentication"
+        end
+      end
+    end
+
+    def install_js_packages
+      if file_exists?("config/importmap.rb") && file_exists?("bin/importmap")
+        run "bin/importmap pin @hotwired/turbo @anycable/web @anycable/turbo-stream"
+      elsif file_exists?("yarn.lock")
+        run "yarn add @anycable/web @anycable/turbo-stream"
+      elsif file_exists?("package-json.lock")
+        run "npm install @anycable/web @anycable/turbo-stream"
+      else
+        false
+      end
+    rescue => e
+      say_status :warn, "Failed to install JS packages: #{e.message}. Skipping..."
+      false
+    end
   end
 end

data/lib/generators/anycable/setup/templates/Procfile.dev.tt

@@ -1,5 +1,5 @@
-web: bin/rails s
+web: bin/rails s -p 3000
 <%- unless http_rpc? -%>
 anycable: bundle exec anycable
 <%- end -%>
-ws: bin/anycable-go <%= anycable_go_options %>
+ws: bin/anycable-go --port 8080

data/lib/generators/anycable/setup/templates/anycable.toml.tt

@@ -0,0 +1,81 @@
+# AnyCable server configuration.
+#
+# Read more at https://docs.anycable.io/anycable-go/configuration
+
+# Public mode disables connection authentication, pub/sub streams and broadcasts verification
+# public = false
+
+# The application secret key: it's used to verify JWT tokens, signed streams, etc.
+# In development, it MUST match the value in the `config/anycable.yml`.
+# IMPORTANT: Make sure you provided a secret in production via the ANYCABLE_SECRET env var
+# if you use this configuration file.
+secret = "anycable-local-secret"
+
+# Enable AnyCable power features such as reliable streams, presence and resumable sessions.
+# Read more:
+#  - https://docs.anycable.io/anycable-go/reliable_streams
+#  - https://docs.anycable.io/anycable-go/presence
+presets = ["broker"]
+
+# Broadcasting adapters for app-to-clients messages.
+# You one of the specified adapters in the config/anycable.yml.
+# Read more in https://docs.anycable.io/anycable-go/broadcasting.
+<%- if redis? -%>
+broadcast_adapters = ["http", "redisx"]
+<%- elsif nats? -%>
+broadcast_adapters = ["http", "nats"]
+<%- else -%>
+broadcast_adapters = ["http"]
+<%- end -%>
+
+# Pub/sub adapter for inter-node communication in a production cluster
+# IMPORTANT: In production, when running AnyCable in a cluster mode,
+# make sure to enable pub/sub adapter via the ANYCABLE_PUBSUB_ADAPTER env var
+# pubsub_adapter = "redis" # or "nats"
+
+[logging]
+debug = true
+
+# RPC is used to authorized subscriptions and perform channel actions.
+# You only need it if you use custom Action Cable channel classes.
+# Read more: https://docs.anycable.io/anycable-go/rpc
+[rpc]
+<%- if http_rpc? -%>
+# IMPORTANT: In production, provide the URL of the RPC service via the ANYCABLE_RPC_HOST env variable
+host = "http://localhost:3000/_anycable"
+<%- elsif grpc? -%>
+host = "localhost:50051"
+<%- else -%>
+# AnyCable is running in a standalone mode.
+# Read more: https://docs.anycable.io/anycable-go/getting_started?id=standalone-mode-pubsub-only
+implementation = "none"
+<%- end -%>
+
+
+# Signed and public streams configuration.
+# Read more: https://docs.anycable.io/anycable-go/signed_streams
+[streams]
+# Enable public (unsigned) streams
+# public = true
+# Enable whispering support for pub/sub streams
+whisper = true
+#
+# Authorize Turbo Streams at the AnyCable server side.
+# IMPORTANT: Make sure your Turbo verifier key is the same as AnyCable secret.
+# Add this line to your Rails configuration (if missing):
+#
+#  config.turbo.signed_stream_verifier_key = AnyCable.config.secret
+#
+turbo = true
+
+<%- if redis? -%>
+[redis]
+# IMPORTANT: In production, provide Redis address via the REDIS_URL or ANYCABLE_REDIS_URL env var
+url = "redis://localhost:6379"
+<%- end -%>
+
+<%- if nats? -%>
+[nats]
+# IMPORTANT: In production, provide NATS address via the ANYCABLE_NATS_SERVERS env var
+servers = "nats://127.0.0.1:4222"
+<%- end -%>

data/lib/generators/anycable/setup/templates/bin/anycable-go.tt

@@ -10,6 +10,11 @@ if [ ! -f ./bin/dist/anycable-go ]; then
   ./bin/rails g anycable:download --version=$version --bin-path=./bin/dist
 fi
 
+if [ -x ./bin/dist/anycable-go ]; then
+  echo "Setting execution permission for AnyCable server"
+  chmod +x ./bin/dist/anycable-go
+fi
+
 curVersion=$(./bin/dist/anycable-go -v)
 
 if [[ "$version" != "latest" ]]; then

data/lib/generators/anycable/setup/templates/bin/dev

@@ -0,0 +1,17 @@
+#!/usr/bin/env sh
+
+# Let the debug gem allow remote connections,
+# but avoid loading until `debugger` is called
+export RUBY_DEBUG_OPEN="true"
+export RUBY_DEBUG_LAZY="true"
+
+if ! command -v overmind &> /dev/null; then
+  if ! gem list foreman -i --silent; then
+    echo "Installing foreman..."
+    gem install foreman
+  fi
+
+  exec foreman start -f Procfile.dev "$@"
+else
+  exec overmind start -f Procfile.dev "$@"
+fi

data/lib/generators/anycable/setup/templates/config/anycable.yml.tt

@@ -1,53 +1,40 @@
-# This file contains per-environment settings for AnyCable.
+# This file contains per-environment settings for AnyCable Rails integration
+# (NOT the AnyCable server).
 #
-# Since AnyCable config is based on anyway_config (https://github.com/palkan/anyway_config), all AnyCable settings
-# can be set or overridden through the corresponding environment variables.
-# E.g., `rpc_host` is overridden by ANYCABLE_RPC_HOST, `debug` by ANYCABLE_DEBUG etc.
-#
-# Note that AnyCable recognizes REDIS_URL env variable for Redis pub/sub adapter. If you want to
-# use another Redis instance for AnyCable, provide ANYCABLE_REDIS_URL variable.
-#
-# Read more about AnyCable configuration here: <%= DOCS_ROOT %>/ruby/configuration
+# The settings specified here would be overriden by the corresponding values in Rails credentials (e.g., `anycable.secret`), or environment variables (e.g., ANYCABLE_SECRET), or any other configuration
+# sources supported by Anyway Config (https://github.com/palkan/anyway_config).
 #
 default: &default
   # Turn on/off access logs ("Started..." and "Finished...")
   access_logs_disabled: false
   # Whether to enable gRPC level logging or not
   log_grpc: false
-  <%- if redis? -%>
-  # Use Redis to broadcast messages to AnyCable server
-  broadcast_adapter: redis
-  <%- elsif nats? -%>
-  # Use NATS to broadcast messages to AnyCable server
-  broadcast_adapter: nats
-  <%- else -%>
-  # Use HTTP broadcaster
+  # Use HTTP broadcaster by default
   broadcast_adapter: http
-  <%- end -%>
-  <%- if redis? -%>
-  # You can use REDIS_URL env var to configure Redis URL.
-  # Localhost is used by default.
-  # redis_url: "redis://localhost:6379/1"
-  # Use the same channel name for WebSocket server, e.g.:
-  #   $ anycable-go --redis_channel="__anycable__"
-  # redis_channel: "__anycable__"
-  <%- end -%>
   <%- if http_rpc? -%>
-  # Use HTTP RPC mounted at the specified path of your web server
-  # Read more about AnyCable RPC:  <%= DOCS_ROOT %>/anycable-go/rpc
-  http_rpc_mount_path: "/_anycable"
+  # Use HTTP RPC mounted at the "/_anycable" path of your web server
+  # Read more: https://docs.anycable.io/anycable-go/rpc?id=rpc-over-http
+  http_rpc: true
   <%- end -%>
+  # This values MUST be the same as in your AnyCable server configuration
+  secret: "anycable-local-secret"
+  # WebSocket endpoint of your AnyCable server for clients to connect to
+  # IMPORTANT: Make sure you have the `action_cable_meta_tag` in your HTML layout
+  # to propogate this value to the client app.
+  # Make sure your AnyCable server runs on port 8080 in development.
+  websocket_url: "ws://localhost:8080/cable"
 
 development:
   <<: *default
-  # WebSocket endpoint of your AnyCable server for clients to connect to
-  # Make sure you have the `action_cable_meta_tag` in your HTML layout
-  # to propogate this value to the client app
-  websocket_url: "ws://localhost:8080/cable"
 
+# Read more about running AnyCable in test env:
+# https://docs.anycable.io/rails/getting_started?id=testing-with-anycable
 test:
   <<: *default
 
 production:
   <<: *default
+  # Use ANYCABLE_WEBSOCKET_URL and ANYCABLE_SECRET environment variables
+  # or credentials or whatever.
   websocket_url: ~
+  secret: ~

data/lib/generators/anycable/setup/templates/config/cable.yml.tt

@@ -1,11 +1,8 @@
-# Make it possible to switch adapters by passing the ACTION_CABLE_ADAPTER env variable.
-# For example, you can use it fallback to the standard Action Cable in staging/review
-# environments (by setting `ACTION_CABLE_ADAPTER=redis`).
 development:
-  adapter: <%%= ENV.fetch("ACTION_CABLE_ADAPTER", "any_cable") %>
+  adapter: any_cable
 
 test:
   adapter: test
 
 production:
-  adapter: <%%= ENV.fetch("ACTION_CABLE_ADAPTER", "any_cable") %>
+  adapter: any_cable