phlex-stimulus 0.1.0

data/lib/phlex/stimulus/components/controller.rb

@@ -0,0 +1,170 @@
+# typed: true
+# frozen_string_literal: true
+
+module Phlex::Stimulus
+  module Components
+    # Abstract class for Phlex components
+    # that wrap Stimulus.js controllers.
+    #
+    # @abstract
+    class Controller < Base
+      class ActionDefinition
+        #: singleton(Controller)
+        attr_reader :component
+        #: String
+        attr_reader :action_name
+
+        #: (component: singleton(Controller), action_name: String) -> void
+        def initialize(component:, action_name:)
+          @component = component
+          @action_name = action_name
+        end
+
+        #: -> String
+        def full_name
+          "#{@component.controller_name}##{@action_name}"
+        end
+
+        #: -> String
+        def ruby_name
+          @action_name.underscore
+        end
+
+        #: -> String
+        def ruby_action_method_name
+          "#{ruby_name}_action"
+        end
+      end
+
+      class TargetDefinition
+        #: singleton(Controller)
+        attr_reader :component
+        #: String
+        attr_reader :target_name
+
+        #: (component: singleton(Controller), target_name: String) -> void
+        def initialize(component:, target_name:)
+          @component = component
+          @target_name = target_name
+        end
+
+        #: -> String
+        def ruby_name
+          @target_name.underscore
+        end
+
+        #: -> String
+        def ruby_target_method_name
+          "#{ruby_name}_target"
+        end
+      end
+
+      class << self
+        # Name of the Stimulus controller
+        #
+        #: String
+        attr_accessor :controller_name
+
+        #: -> String
+        def controller_path
+          name = controller_name
+          sections = name.split('--')
+          subpath = sections.map(&:underscore).join('/')
+
+          "app/javascript/controllers/#{subpath}_controller.ts"
+        end
+
+        #: -> Array[ActionDefinition]
+        def action_defs
+          @action_defs ||= []
+        end
+
+        #: -> Array[TargetDefinition]
+        def target_defs
+          @target_defs ||= []
+        end
+
+        # Constructs a Stimulus dispatched event name
+        # eg.
+        #
+        #     SummaryController.dispatched('ready') #=> "summary:ready"
+        #
+        #: (String) -> String
+        def dispatched(event_name)
+          "#{controller_name}:#{event_name}"
+        end
+
+        # Returns the name of the data attribute for the controller's targets without the initial `"data-"`
+        # eg. `"summary-target"`
+        #
+        #: -> String
+        def target_key
+          "#{controller_name}-target"
+        end
+
+        # Returns the full name of the data attribute for the controller's targets
+        # eg. `"data-summary-target"`
+        #
+        #: -> String
+        def data_target_key
+          "data-#{target_key}"
+        end
+
+        # Register actions that exist on the Stimulus controller.
+        # Will define typed getter methods for each action.
+        #
+        #: (*Symbol) -> void
+        def actions(*actions)
+          actions.each do |action|
+            action_def = ActionDefinition.new(
+              component:   self,
+              action_name: action.to_s,
+            )
+            action_defs << action_def
+
+            instance_eval <<~RUBY, __FILE__, __LINE__ + 1
+              def #{action_def.ruby_action_method_name}
+                "\#{controller_name}##{action}"
+              end
+            RUBY
+          end
+        end
+
+        # Register targets that exist on the Stimulus controller.
+        # Will define typed getter methods for each target.
+        #
+        #: (*Symbol) -> void
+        def targets(*targets)
+          targets.each do |target|
+            target_str = target.to_s
+            target_def = TargetDefinition.new(
+              component:   self,
+              target_name: target_str,
+            )
+            target_defs << target_def
+
+            instance_eval <<~RUBY, __FILE__, __LINE__ + 1
+              def #{target_def.ruby_target_method_name}
+                #{target_str.inspect}
+              end
+            RUBY
+          end
+        end
+
+      end
+
+      #: -> String
+      def controller_name
+        self.class.controller_name
+      end
+
+      # @overridable
+      #: ?{ -> void } -> void
+      def view_template(&block)
+        div(data: { controller: self.class.controller_name }) do
+          block&.call
+        end
+      end
+    end
+  end
+end

data/lib/phlex/stimulus/components.rb

@@ -0,0 +1,9 @@
+# typed: true
+# frozen_string_literal: true
+
+module Phlex::Stimulus
+  # Contains Phlex on Rails base components
+  module Components; end
+end
+
+require_relative 'components/base'

data/lib/phlex/stimulus/version.rb

@@ -0,0 +1,8 @@
+# typed: true
+# frozen_string_literal: true
+
+module Phlex
+  module Stimulus
+    VERSION = '0.1.0'
+  end
+end

data/lib/phlex/stimulus.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative 'stimulus/version'
+
+require 'rails'
+require 'phlex'
+require 'phlex/rails'
+require 'booleans'
+
+module Phlex
+  module Stimulus
+  end
+end
+
+require_relative 'stimulus/components'

data/sorbet/config

@@ -0,0 +1,7 @@
+--dir
+.
+--enable-experimental-requires-ancestor
+--enable-experimental-rbs-comments
+--parser=prism
+--ignore=tmp/
+--ignore=vendor/

data/sorbet/rbi/annotations/.gitattributes

@@ -0,0 +1 @@
+**/*.rbi linguist-vendored=true

data/sorbet/rbi/annotations/actionmailer.rbi

@@ -0,0 +1,15 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This file was pulled from a central RBI files repository.
+# Please run `bin/tapioca annotations` to update it.
+
+class ActionMailer::Base
+  sig { params(headers: T.untyped, block: T.nilable(T.proc.params(arg0: ActionMailer::Collector).void)).returns(Mail::Message) }
+  def mail(headers = nil, &block); end
+end
+
+module ActionMailer::TestHelper
+  sig { params(block: T.proc.void).returns(T::Array[Mail::Message]) }
+  def capture_emails(&block); end
+end

data/sorbet/rbi/annotations/actionpack.rbi

@@ -0,0 +1,430 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This file was pulled from a central RBI files repository.
+# Please run `bin/tapioca annotations` to update it.
+
+class ActionController::API
+  MODULES = T.let(T.unsafe(nil), T::Array[T.untyped])
+end
+
+module ActionController::Flash::ClassMethods
+  sig { params(types: Symbol).void }
+  def add_flash_types(*types); end
+end
+
+module ActionController::Helpers::ClassMethods
+  sig { returns(ActionView::Base) }
+  def helpers; end
+end
+
+class ActionController::Metal < AbstractController::Base
+  sig { returns(ActionController::Parameters) }
+  def params; end
+
+  sig { returns(ActionDispatch::Request) }
+  def request; end
+
+  sig { returns(ActionDispatch::Response) }
+  def response; end
+end
+
+module ActionController::MimeResponds
+  sig { params(mimes: T.nilable(Symbol), block: T.nilable(T.proc.params(arg0: ActionController::MimeResponds::Collector).void)).void }
+  def respond_to(*mimes, &block); end
+end
+
+class ActionController::Parameters
+  sig { params(other: T.any(String, ActionController::Parameters)).returns(T::Boolean) }
+  def ==(other); end
+
+  sig { params(key: T.any(String, Symbol), value: T.untyped).void }
+  def []=(key, value); end
+
+  sig { returns(T.nilable(T::Array[T.any(String, Symbol)])) }
+  def always_permitted_parameters; end
+
+  sig { params(obj: T.nilable(T::Array[T.any(String, Symbol)])).void }
+  def always_permitted_parameters=(obj); end
+
+  sig { returns(T.untyped) }
+  def deep_dup; end
+
+  sig { params(key: T.any(String, Symbol), block: T.untyped).returns(T.untyped) }
+  def delete(key, &block); end
+
+  sig { params(keys: T.any(String, Symbol)).returns(T.untyped) }
+  def dig(*keys); end
+
+  sig { params(block: T.untyped).returns(T.untyped) }
+  def each_pair(&block); end
+
+  # each is an alias of each_pair
+  sig { params(block: T.untyped).returns(T.untyped) }
+  def each(&block); end
+
+  sig { params(keys: T.any(String, Symbol)).returns(ActionController::Parameters) }
+  def except(*keys); end
+
+  sig { params(keys: T.any(String, Symbol)).returns(T.untyped) }
+  def extract!(*keys); end
+
+  sig { params(key: T.any(String, Symbol), args: T.untyped, block: T.nilable(T.proc.params(key: T.any(String, Symbol)).returns(T.untyped))).returns(T.untyped) }
+  def fetch(key, *args, &block); end
+
+  sig { returns(String) }
+  def inspect; end
+
+  sig { params(other_hash: T.untyped, block: T.untyped).returns(ActionController::Parameters) }
+  def merge!(other_hash, &block); end
+
+  sig { params(other_hash: T.untyped).returns(ActionController::Parameters) }
+  def merge(other_hash); end
+
+  sig { returns(T.untyped) }
+  def parameters; end
+
+  sig { returns(T.self_type) }
+  def permit!; end
+
+  # You can pass _a lot_ of stuff to permit, so filters is left untyped for now.
+  sig { params(filters: T.untyped).returns(ActionController::Parameters) }
+  def permit(*filters); end
+
+  sig { params(new_permitted: T.untyped).void }
+  def permitted=(new_permitted); end
+
+  sig { returns(T::Boolean) }
+  def permitted?; end
+
+  sig { params(block: T.untyped).returns(T.untyped) }
+  def reject!(&block); end
+
+  # delete_if is an alias of reject!
+  sig { params(block: T.untyped).returns(T.untyped) }
+  def delete_if(&block); end
+
+  sig { params(block: T.untyped).returns(T.untyped) }
+  def reject(&block); end
+
+  sig { params(key: T.any(String, Symbol)).returns(T.untyped) }
+  def [](key); end
+
+  sig { params(key: T.any(String, Symbol)).returns(T.untyped) }
+  sig { params(key: T::Array[T.any(String, Symbol)]).returns(T::Array[T.untyped]) }
+  def require(key); end
+
+  # required is an alias of require
+  sig { params(key: T.any(String, Symbol)).returns(T.untyped) }
+  sig { params(key: T::Array[T.any(String, Symbol)]).returns(T::Array[T.untyped]) }
+  def required(key); end
+
+  sig { params(other_hash: T.untyped).returns(ActionController::Parameters) }
+  def reverse_merge!(other_hash); end
+
+  # with_defaults! is an alias of reverse_merge!
+  sig { params(other_hash: T.untyped).returns(ActionController::Parameters) }
+  def with_defaults!(other_hash); end
+
+  sig { params(other_hash: T.untyped).returns(ActionController::Parameters) }
+  def reverse_merge(other_hash); end
+
+  # with_defaults is an alias of reverse_merge
+  sig { params(other_hash: T.untyped).returns(ActionController::Parameters) }
+  def with_defaults(other_hash); end
+
+  sig { params(block: T.untyped).returns(T.nilable(ActionController::Parameters)) }
+  def select!(&block); end
+
+  # keep_if is an alias of select!
+  sig { params(block: T.untyped).returns(T.nilable(ActionController::Parameters)) }
+  def keep_if(&block); end
+
+  sig { params(block: T.untyped).returns(ActionController::Parameters) }
+  def select(&block); end
+
+  sig { params(keys: T.any(String, Symbol)).returns(ActionController::Parameters) }
+  def slice!(*keys); end
+
+  sig { params(keys: T.any(String, Symbol)).returns(ActionController::Parameters) }
+  def slice(*keys); end
+
+  sig { params(block: T.nilable(Proc)).returns(ActiveSupport::HashWithIndifferentAccess) }
+  def to_h(&block); end
+
+  sig { returns(T::Hash[T.untyped, T.untyped]) }
+  def to_hash; end
+
+  # to_param is an alias of to_query
+  sig { params(args: String).returns(T.nilable(String)) }
+  def to_param(*args); end
+
+  sig { params(args: String).returns(T.nilable(String)) }
+  def to_query(*args); end
+
+  sig { returns(ActiveSupport::HashWithIndifferentAccess) }
+  def to_unsafe_h; end
+
+  # to_unsafe_hash is an alias of to_unsafe_h
+  sig { returns(ActiveSupport::HashWithIndifferentAccess) }
+  def to_unsafe_hash; end
+
+  sig { params(block: T.untyped).returns(ActionController::Parameters) }
+  def transform_keys!(&block); end
+
+  sig { params(block: T.untyped).returns(ActionController::Parameters) }
+  def transform_keys(&block); end
+
+  sig { params(block: T.nilable(T.proc.params(value: T.untyped).returns(T.untyped))).returns(ActionController::Parameters) }
+  def transform_values!(&block); end
+
+  sig { params(block: T.nilable(T.proc.params(value: T.untyped).returns(T.untyped))).returns(ActionController::Parameters) }
+  def transform_values(&block); end
+
+  sig { params(keys: T.any(String, Symbol)).returns(T.untyped) }
+  def values_at(*keys); end
+
+  sig { returns(T.any(Symbol, T::Boolean)) }
+  def self.action_on_unpermitted_parameters; end
+
+  sig { params(obj: T.any(Symbol, T::Boolean)).void }
+  def self.action_on_unpermitted_parameters=(obj); end
+
+  sig { returns(T::Array[T.any(String, Symbol)]) }
+  def self.always_permitted_parameters; end
+
+  sig { params(obj: T::Array[T.any(String, Symbol)]).void }
+  def self.always_permitted_parameters=(obj); end
+
+  sig { returns(T::Boolean) }
+  def self.permit_all_parameters; end
+
+  sig { params(obj: T::Boolean).void }
+  def self.permit_all_parameters=(obj); end
+end
+
+module ActionController::RequestForgeryProtection
+  sig { returns(T::Boolean) }
+  def protect_against_forgery?; end
+
+  sig { params(form_options: T::Hash[T.untyped, T.untyped]).returns(String) }
+  def form_authenticity_token(form_options: {}); end
+end
+
+module ActionController::RequestForgeryProtection::ClassMethods
+  sig { params(options: T::Hash[T.untyped, T.untyped]).void }
+  def skip_forgery_protection(options = T.unsafe(nil)); end
+end
+
+module ActionController::StrongParameters
+  sig { returns(ActionController::Parameters) }
+  def params; end
+end
+
+module ActionDispatch::Http::Parameters
+  sig { returns(ActionController::Parameters) }
+  def parameters; end
+
+  # params is an alias of parameters
+  sig { returns(ActionController::Parameters) }
+  def params; end
+end
+
+module ActionDispatch::Integration::Runner
+  # @method_missing: delegated to ActionDispatch::Integration::Session
+  sig { params(host: String).returns(String) }
+  def host!(host); end
+
+  # @method_missing: delegated to ActionDispatch::Integration::Session
+  sig { params(flag: T::Boolean).returns(T::Boolean) }
+  def https!(flag = true); end
+end
+
+class ActionDispatch::IntegrationTest
+  # The following methods are accessible on `IntegrationTest`
+  # through the following delegation chain:
+  # - `IntegrationTest` includes `IntegrationTest::Behavior`
+  # - `IntegrationTest::Behavior` includes `Integration::Runner`
+  # - `Integration::Runner#method_missing` delegates to `Integration::Session`
+  #
+  # Then `Integration::Session` either implements the methods
+  # directly or further delegates to `TestProcess` (included) or
+  # `TestResponse` / `Request` (via `delegate`).
+  #
+  # Cf. https://github.com/Shopify/rbi-central/pull/138 for more context.
+  # @method_missing: delegated to ActionDispatch::TestProcess
+  sig { returns(ActionDispatch::Flash::FlashHash) }
+  def flash; end
+
+  # @method_missing: delegated to ActionDispatch::TestProcess
+  sig { returns(ActionDispatch::Request::Session) }
+  def session; end
+
+  # @method_missing: delegated to ActionDispatch::TestResponse
+  sig { returns(T.nilable(Integer)) }
+  def status; end
+
+  # @method_missing: delegated to ActionDispatch::TestResponse
+  sig { returns(T.nilable(String)) }
+  def status_message; end
+
+  # @method_missing: delegated to ActionDispatch::TestResponse
+  sig { returns(ActionDispatch::Response::Header) }
+  def headers; end
+
+  # @method_missing: delegated to ActionDispatch::TestResponse
+  sig { returns(T.nilable(String)) }
+  def body; end
+
+  # @method_missing: delegated to ActionDispatch::TestResponse
+  sig { returns(T.nilable(T::Boolean)) }
+  def redirect?; end
+
+  # @method_missing: delegated to ActionDispatch::Request
+  sig { returns(T.nilable(String)) }
+  def path; end
+
+  # @method_missing: delegated to ActionDispatch::Integration::Session
+  sig { returns(String) }
+  def host; end
+
+  # @method_missing: delegated to ActionDispatch::Integration::Session
+  sig { params(host: String).returns(String) }
+  attr_writer :host
+
+  # @method_missing: delegated to ActionDispatch::Integration::Session
+  sig { returns(T.nilable(String)) }
+  attr_accessor :remote_addr
+
+  # @method_missing: delegated to ActionDispatch::Integration::Session
+  sig { returns(T.nilable(String)) }
+  attr_accessor :accept
+
+  # @method_missing: delegated to ActionDispatch::Integration::Session
+  sig { returns(Rack::Test::CookieJar) }
+  def cookies; end
+
+  # @method_missing: delegated to ActionDispatch::Integration::Session
+  sig { returns(T.nilable(ActionController::Base)) }
+  attr_reader :controller
+
+  # @method_missing: delegated to ActionDispatch::Integration::Session
+  sig { returns(ActionDispatch::TestRequest) }
+  attr_reader :request
+
+  # @method_missing: delegated to ActionDispatch::Integration::Session
+  sig { returns(ActionDispatch::TestResponse) }
+  attr_reader :response
+
+  # @method_missing: delegated to ActionDispatch::Integration::Session
+  sig { returns(Integer) }
+  attr_accessor :request_count
+end
+
+class ActionDispatch::Request
+  # Provides access to the request's HTTP headers, for example:
+  #
+  # ```ruby
+  # request.headers["Content-Type"] # => "text/plain"
+  # ```
+  sig { returns(ActionDispatch::Http::Headers) }
+  def headers; end
+
+  # Returns a `String` with the last requested path including their params.
+  #
+  # ```ruby
+  # # get '/foo'
+  # request.original_fullpath # => '/foo'
+  #
+  # # get '/foo?bar'
+  # request.original_fullpath # => '/foo?bar'
+  # ```
+  sig { returns(String) }
+  def original_fullpath; end
+
+  # Returns the `String` full path including params of the last URL requested.
+  #
+  # ```ruby
+  # # get "/articles"
+  # request.fullpath # => "/articles"
+  #
+  # # get "/articles?page=2"
+  # request.fullpath # => "/articles?page=2"
+  # ```
+  sig { returns(String) }
+  def fullpath; end
+
+  # Returns the original request URL as a `String`.
+  #
+  # ```ruby
+  # # get "/articles?page=2"
+  # request.original_url # => "http://www.example.com/articles?page=2"
+  # ```
+  sig { returns(String) }
+  def original_url; end
+
+  # The `String` MIME type of the request.
+  #
+  # ```
+  # # get "/articles"
+  # request.media_type # => "application/x-www-form-urlencoded"
+  # ```
+  sig { returns(String) }
+  def media_type; end
+
+  # Returns the content length of the request as an integer.
+  sig { returns(Integer) }
+  def content_length; end
+
+  # Returns the IP address of client as a `String`.
+  sig { returns(String) }
+  def ip; end
+
+  # Returns the IP address of client as a `String`,
+  # usually set by the RemoteIp middleware.
+  sig { returns(String) }
+  def remote_ip; end
+
+  # Returns the unique request id, which is based on either the X-Request-Id header that can
+  # be generated by a firewall, load balancer, or web server or by the RequestId middleware
+  # (which sets the action_dispatch.request_id environment variable).
+  #
+  # This unique ID is useful for tracing a request from end-to-end as part of logging or debugging.
+  # This relies on the Rack variable set by the ActionDispatch::RequestId middleware.
+  sig { returns(T.nilable(String)) }
+  def request_id; end
+
+  # Returns true if the request has a header matching the given key parameter.
+  #
+  # ```ruby
+  # request.key? :ip_spoofing_check # => true
+  # ```
+  sig { params(key: Symbol).returns(T::Boolean) }
+  def key?(key); end
+
+  # True if the request came from localhost, 127.0.0.1, or ::1.
+  sig { returns(T::Boolean) }
+  def local?; end
+end
+
+module ActionDispatch::Routing::Mapper::Resources
+  sig { params(name: T.untyped).returns(T.untyped) }
+  def action_path(name); end
+
+  sig { params(block: T.untyped).returns(T.untyped) }
+  def collection(&block); end
+
+  sig { params(block: T.untyped).returns(T.untyped) }
+  def member(&block); end
+
+  sig { returns(T.untyped) }
+  def shallow; end
+
+  sig { returns(T::Boolean) }
+  def shallow?; end
+end
+
+class ActionDispatch::Routing::RouteSet
+  sig { params(block: T.proc.bind(ActionDispatch::Routing::Mapper).void).void }
+  def draw(&block); end
+end