cable_ready 4.4.6 → 5.0.0.pre2

data/lib/cable_ready/operation_builder.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module CableReady
+  class OperationBuilder
+    include Identifiable
+    attr_reader :identifier, :previous_selector
+
+    def self.finalizer_for(identifier)
+      proc {
+        channel = CableReady.config.observers.find { |o| o.try(:identifier) == identifier }
+        CableReady.config.delete_observer channel if channel
+      }
+    end
+
+    def initialize(identifier)
+      @identifier = identifier
+
+      reset!
+      CableReady.config.operation_names.each { |name| add_operation_method name }
+      CableReady.config.add_observer self, :add_operation_method
+      ObjectSpace.define_finalizer self, self.class.finalizer_for(identifier)
+    end
+
+    def add_operation_method(name)
+      return if respond_to?(name)
+      singleton_class.public_send :define_method, name, ->(*args) {
+        if args.one? && args.first.respond_to?(:to_operation_options) && [Array, Hash].include?(args.first.to_operation_options.class)
+          case args.first.to_operation_options
+          when Array
+            selector, options = nil, args.first.to_operation_options
+              .select { |e| e.is_a?(Symbol) && args.first.respond_to?("to_#{e}".to_sym) }
+              .each_with_object({}) { |option, memo| memo[option.to_s] = args.first.send("to_#{option}".to_sym) }
+          when Hash
+            selector, options = nil, args.first.to_operation_options
+          else
+            raise TypeError, ":to_operation_options returned an #{args.first.to_operation_options.class.name}. Must be an Array or Hash."
+          end
+        else
+          selector, options = nil, args.first || {} # 1 or 0 params
+          selector, options = options, {} unless options.is_a?(Hash) # swap if only selector provided
+          selector, options = args[0, 2] if args.many? # 2 or more params
+          options.stringify_keys!
+          options.each { |key, value| options[key] = value.send("to_#{key}".to_sym) if value.respond_to?("to_#{key}".to_sym) }
+        end
+        options["selector"] = selector if selector && options.exclude?("selector")
+        options["selector"] = previous_selector if previous_selector && options.exclude?("selector")
+        if options.include?("selector")
+          @previous_selector = options["selector"]
+          options["selector"] = identifiable?(previous_selector) ? dom_id(previous_selector) : previous_selector
+        end
+        @enqueued_operations[name.to_s] << options
+        self
+      }
+    end
+
+    def to_json(*args)
+      @enqueued_operations.to_json(*args)
+    end
+
+    def apply!(operations = "{}")
+      operations = begin
+        JSON.parse(operations.is_a?(String) ? operations : operations.to_json)
+      rescue JSON::ParserError
+        {}
+      end
+      operations.each do |name, operation|
+        operation.each do |enqueued_operation|
+          @enqueued_operations[name.to_s] << enqueued_operation
+        end
+      end
+      self
+    end
+
+    def operations_payload
+      @enqueued_operations.select { |_, list| list.present? }.deep_transform_keys { |key| key.to_s.camelize(:lower) }
+    end
+
+    def reset!
+      @enqueued_operations = Hash.new { |hash, key| hash[key] = [] }
+      @previous_selector = nil
+    end
+  end
+end

data/lib/cable_ready/sanity_checker.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+class CableReady::SanityChecker
+  LATEST_VERSION_FORMAT = /^(\d+\.\d+\.\d+)$/
+  NODE_VERSION_FORMAT = /(\d+\.\d+\.\d+.*):/
+  JSON_VERSION_FORMAT = /(\d+\.\d+\.\d+.*)"/
+
+  class << self
+    def check!
+      return if ENV["SKIP_SANITY_CHECK"]
+      return if CableReady.config.on_failed_sanity_checks == :ignore
+      return if called_by_generate_config?
+      return if called_by_rake?
+
+      instance = new
+      instance.check_package_versions_match
+      instance.check_new_version_available
+    end
+
+    private
+
+    def called_by_generate_config?
+      ARGV.include?("cable_ready:initializer")
+    end
+
+    def called_by_rake?
+      File.basename($PROGRAM_NAME) == "rake"
+    end
+  end
+
+  def check_package_versions_match
+    if npm_version.nil?
+      warn_and_exit <<~WARN
+        👉 Can't locate the cable_ready npm package.
+
+          yarn add cable_ready@#{gem_version}
+
+        Either add it to your package.json as a dependency or use "yarn link cable_ready" if you are doing development.
+      WARN
+    end
+
+    if package_version_mismatch?
+      warn_and_exit <<~WARN
+        👉 The cable_ready npm package version (#{npm_version}) does not match the Rubygem version (#{gem_version}).
+
+        To update the cable_ready npm package:
+
+          yarn upgrade cable_ready@#{gem_version}
+      WARN
+    end
+  end
+
+  def check_new_version_available
+    return if CableReady.config.on_new_version_available == :ignore
+    return if Rails.env.development? == false
+    return if using_preview_release?
+    begin
+      latest_version = URI.open("https://raw.githubusercontent.com/stimulusreflex/cable_ready/master/LATEST", open_timeout: 1, read_timeout: 1).read.strip
+      if latest_version != CableReady::VERSION
+        puts <<~WARN
+
+          👉 There is a new version of CableReady available!
+          Current: #{CableReady::VERSION} Latest: #{latest_version}
+
+          If you upgrade, it is very important that you update BOTH Gemfile and package.json
+          Then, run `bundle install && yarn install` to update to #{latest_version}.
+
+        WARN
+        exit if CableReady.config.on_new_version_available == :exit
+      end
+    rescue
+      puts "👉 CableReady #{CableReady::VERSION} update check skipped: connection timeout"
+    end
+  end
+
+  private
+
+  def package_version_mismatch?
+    npm_version != gem_version
+  end
+
+  def using_preview_release?
+    preview = CableReady::VERSION.match?(LATEST_VERSION_FORMAT) == false
+    puts "👉 CableReady #{CableReady::VERSION} update check skipped: pre-release build" if preview
+    preview
+  end
+
+  def gem_version
+    @_gem_version ||= CableReady::VERSION.gsub(".pre", "-pre")
+  end
+
+  def npm_version
+    @_npm_version ||= find_npm_version
+  end
+
+  def find_npm_version
+    if (match = search_file(package_json_path, regex: /version/))
+      match[JSON_VERSION_FORMAT, 1]
+    elsif (match = search_file(yarn_lock_path, regex: /^cable_ready/))
+      match[NODE_VERSION_FORMAT, 1]
+    end
+  end
+
+  def search_file(path, regex:)
+    return if File.exist?(path) == false
+    File.foreach(path).grep(regex).first
+  end
+
+  def package_json_path
+    Rails.root.join("node_modules", "cable_ready", "package.json")
+  end
+
+  def yarn_lock_path
+    Rails.root.join("yarn.lock")
+  end
+
+  def initializer_missing?
+    File.exist?(Rails.root.join("config", "initializers", "cable_ready.rb")) == false
+  end
+
+  def warn_and_exit(text)
+    puts
+    puts "Heads up! 🔥"
+    puts
+    puts text
+    puts
+    if CableReady.config.on_failed_sanity_checks == :exit
+      puts <<~INFO
+        To ignore any warnings and start the application anyway, you can set the SKIP_SANITY_CHECK environment variable:
+
+          SKIP_SANITY_CHECK=true rails
+
+        To do this permanently, add the following directive to the CableReady initializer:
+
+          CableReady.configure do |config|
+            config.on_failed_sanity_checks = :warn
+          end
+
+      INFO
+      if initializer_missing?
+        puts <<~INFO
+          You can create a CableReady initializer with the command:
+
+            bundle exec rails generate cable_ready:initializer
+
+        INFO
+      end
+      exit false if Rails.env.test? == false
+    end
+  end
+end

data/lib/cable_ready/stream_identifier.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module CableReady
+  module StreamIdentifier
+    def verified_stream_identifier(signed_stream_identifier)
+      CableReady.signed_stream_verifier.verified signed_stream_identifier
+    end
+
+    def signed_stream_identifier(compoundable)
+      CableReady.signed_stream_verifier.generate compoundable
+    end
+  end
+end

data/lib/cable_ready/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module CableReady
-  VERSION = "4.4.6"
+  VERSION = "5.0.0.pre2"
 end

data/lib/generators/cable_ready/channel_generator.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+class CableReady::ChannelGenerator < Rails::Generators::NamedBase
+  source_root File.expand_path("templates", __dir__)
+
+  class_option :stream_from, type: :string
+  class_option :stream_for, type: :string
+  class_option :stimulus, type: :boolean
+
+  def check_options
+    raise "Can't specify --stream-from and --stream-for at the same time" if options.key?(:stream_from) && options.key?(:stream_for)
+  end
+
+  def create_channel
+    generate "channel", file_name
+  end
+
+  def enhance_channels
+    if using_broadcast_to?
+      gsub_file "app/channels/#{file_name}_channel.rb", /# stream_from.*\n/, "stream_for #{resource}.find(params[:id])\n"
+      template "app/javascript/controllers/%file_name%_controller.js" if using_stimulus?
+    else
+      prepend_to_file "app/javascript/channels/#{file_name}_channel.js", "import CableReady from 'cable_ready'\n"
+      inject_into_file "app/javascript/channels/#{file_name}_channel.js", after: "// Called when there's incoming data on the websocket for this channel\n" do
+        <<-JS
+    if (data.cableReady) CableReady.perform(data.operations)
+        JS
+      end
+
+      gsub_file "app/channels/#{file_name}_channel.rb", /# stream_from.*\n/, "stream_from \"#{identifier}\"\n"
+    end
+  end
+
+  private
+
+  def option_given?
+    options.key?(:stream_from) || options.key?(:stream_for)
+  end
+
+  def using_broadcast_to?
+    @using_broadcast_to ||= option_given? ? options.key?(:stream_for) : yes?("Are you streaming to a resource using broadcast_to? (y/N)")
+  end
+
+  def using_stimulus?
+    @using_stimulus ||= options.fetch(:stimulus) {
+      yes?("Are you going to use a Stimulus controller to subscribe to this channel? (y/N)")
+    }
+  end
+
+  def resource
+    return @resource if @resource
+
+    stream_for = options.fetch(:stream_for) {
+      ask("Which resource are you streaming for?", default: class_name)
+    }
+
+    stream_for = file_name if stream_for == "stream_for"
+    @resource = stream_for.camelize
+  end
+
+  def identifier
+    return @identifier if @identifier
+
+    stream_from = options.fetch(:stream_from) {
+      ask("What is the stream identifier that goes into stream_from?", default: file_name)
+    }
+
+    stream_from = file_name if stream_from == "stream_from"
+    @identifier = stream_from.underscore
+  end
+end

data/lib/generators/cable_ready/initializer_generator.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+
+module CableReady
+  class InitializerGenerator < Rails::Generators::Base
+    desc "Creates a CableReady initializer template in config/initializers"
+    source_root File.expand_path("templates", __dir__)
+
+    def copy_initializer_file
+      copy_file "config/initializers/cable_ready.rb"
+    end
+  end
+end

data/lib/generators/cable_ready/stream_from_generator.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "fileutils"
+
+module CableReady
+  class StreamFromGenerator < Rails::Generators::Base
+    desc "Initializes CableReady with a reference to the shared ActionCable consumer"
+    source_root File.expand_path("templates", __dir__)
+
+    def copy_controller_file
+      main_folder = defined?(Webpacker) ? Webpacker.config.source_path.to_s.gsub("#{Rails.root}/", "") : "app/javascript"
+
+      filepath = [
+        "#{main_folder}/controllers/index.js",
+        "#{main_folder}/controllers/index.ts",
+        "#{main_folder}/packs/application.js",
+        "#{main_folder}/packs/application.ts"
+      ]
+        .select { |path| File.exist?(path) }
+        .map { |path| Rails.root.join(path) }
+        .first
+
+      lines = File.open(filepath, "r") { |f| f.readlines }
+
+      unless lines.find { |line| line.start_with?("import CableReady") }
+        matches = lines.select { |line| line =~ /\A(require|import)/ }
+        lines.insert lines.index(matches.last).to_i + 1, "import CableReady from 'cable_ready'\n"
+        File.open(filepath, "w") { |f| f.write lines.join }
+      end
+
+      unless lines.find { |line| line.start_with?("import consumer") }
+        matches = lines.select { |line| line =~ /\A(require|import)/ }
+        lines.insert lines.index(matches.last).to_i + 1, "import consumer from '../channels/consumer'\n"
+        File.open(filepath, "w") { |f| f.write lines.join }
+      end
+
+      unless lines.find { |line| line.include?("CableReady.initialize({ consumer })") }
+        append_to_file filepath, "CableReady.initialize({ consumer })"
+      end
+    end
+  end
+end

data/lib/generators/cable_ready/templates/config/initializers/cable_ready.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+CableReady.configure do |config|
+  # Enable/disable exiting / warning when the sanity checks fail options:
+  # `:exit` or `:warn` or `:ignore`
+
+  # config.on_failed_sanity_checks = :exit
+
+  # Enable/disable exiting / warning when there's a new CableReady release
+  # `:exit` or `:warn` or `:ignore`
+
+  # config.on_new_version_available = :ignore
+
+  # Define your own custom operations
+  # https://cableready.stimulusreflex.com/customization#custom-operations
+
+  # config.add_operation_name :jazz_hands
+end

data/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cable_ready",
-  "version": "4.4.5",
+  "version": "5.0.0-pre1",
   "description": "CableReady helps you create great real-time user experiences by making it simple to trigger client-side DOM changes from server-side Ruby.",
   "keywords": [
     "ruby",
@@ -15,17 +15,22 @@
   ],
   "homepage": "https://cableready.stimulusreflex.com/",
   "bugs": {
-    "url": "https://github.com/hopsoft/cable_ready/issues"
+    "url": "https://github.com/stimulusreflex/cable_ready/issues"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com:hopsoft/cable_ready.git"
+    "url": "git+https://github.com:stimulusreflex/cable_ready.git"
   },
   "license": "MIT",
   "author": "Nathan Hopkins <natehop@gmail.com>",
-  "main": "./javascript/cable_ready.js",
+  "main": "./javascript/index.js",
+  "module": "./javascript/index.js",
+  "sideEffects": false,
   "scripts": {
-    "prettier-standard-check": "yarn run prettier-standard --check ./javascript/**/*.js"
+    "lint": "yarn run prettier-standard:check",
+    "format": "yarn run prettier-standard:format",
+    "prettier-standard:check": "yarn run prettier-standard --check ./javascript/**/*.js",
+    "prettier-standard:format": "yarn run prettier-standard ./javascript/**/*.js"
   },
   "dependencies": {
     "morphdom": "^2.6.1"