js-routes 2.2.9 → 2.2.10

data/js-routes.gemspec

@@ -1,42 +0,0 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'js_routes/version'
-
-Gem::Specification.new do |s|
-  s.name = %q{js-routes}
-  s.version = JsRoutes::VERSION
-
-  if s.respond_to? :required_rubygems_version=
-    s.required_rubygems_version = Gem::Requirement.new(">= 0")
-  end
-  s.authors = ["Bogdan Gusiev"]
-  s.description = %q{Generates javascript file that defines all Rails named routes as javascript helpers}
-  s.email = %q{agresso@gmail.com}
-  s.extra_rdoc_files = [
-    "LICENSE.txt"
-  ]
-  s.required_ruby_version = '>= 2.4.0'
-  s.files = `git ls-files`.split("\n")
-  s.homepage = %q{http://github.com/railsware/js-routes}
-  s.licenses = ["MIT"]
-  s.require_paths = ["lib"]
-  s.summary = %q{Brings Rails named routes to javascript}
-  s.metadata = { "github_repo" => "ssh://github.com/railsware/js-routes" }
-
-  s.add_runtime_dependency(%q<railties>, [">= 4"])
-  s.add_runtime_dependency(%q<sorbet-runtime>)
-
-  s.add_development_dependency(%q<sprockets-rails>)
-  s.add_development_dependency(%q<rspec>, [">= 3.10.0"])
-  s.add_development_dependency(%q<bundler>, [">= 2.2.25"])
-  s.add_development_dependency(%q<appraisal>, [">= 0.5.2"])
-  s.add_development_dependency(%q<bump>, [">= 0.10.0"])
-  if defined?(JRUBY_VERSION)
-    s.add_development_dependency(%q<therubyrhino>, [">= 2.0.4"])
-  else
-    s.add_development_dependency(%q<byebug>)
-    s.add_development_dependency(%q<pry-byebug>)
-    s.add_development_dependency(%q<mini_racer>, [">= 0.4.0"])
-  end
-end

data/package.json

@@ -1,38 +0,0 @@
-{
-  "name": "js-routes",
-  "version": "1.0.0",
-  "main": "index.js",
-  "repository": "git@github.com:railsware/js-routes.git",
-  "author": "Bogdan Gusiev <agresso@gmail.com>, Alexey Vasiliev <https://leopard.in.ua> ",
-  "license": "MIT",
-  "private": false,
-  "devDependencies": {
-    "typescript": "^4.1.2"
-  },
-  "dependencies": {
-    "@typescript-eslint/eslint-plugin": "^4.9.0",
-    "@typescript-eslint/parser": "^4.9.0",
-    "eslint": "^8.35.0",
-    "eslint-config-prettier": "^8.7.0",
-    "eslint-plugin-import": "^2.27.5",
-    "husky": "^4.3.0",
-    "lint-staged": "^10.5.2",
-    "pinst": "^2.1.1",
-    "prettier": "^2.8.4"
-  },
-  "scripts": {
-    "build": "tsc && yarn lint:fix",
-    "lint:fix": "yarn eslint --fix && yarn prettier --write lib/routes.ts",
-    "postinstall": "yarn husky-upgrade"
-  },
-  "husky": {
-    "hooks": {
-      "pre-commit": "yarn lint:fix"
-    }
-  },
-  "lint-staged": {
-    "./lib/routes.ts": [
-      "yarn lint:fix"
-    ]
-  }
-}

data/sorbet/config

@@ -1,4 +0,0 @@
---dir
-.
---ignore=tmp/
---ignore=vendor/

data/sorbet/rbi/annotations/.gitattributes

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

data/sorbet/rbi/annotations/actionpack.rbi

@@ -1,428 +0,0 @@
-# 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).returns(T.untyped) }
-  def fetch(key, *args); 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, T::Array[T.any(String, Symbol)])).returns(T.untyped) }
-  def require(key); end
-
-  # required is an alias of require
-  sig { params(key: T.any(String, Symbol, T::Array[T.any(String, Symbol)])).returns(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 { returns(ActionController::Parameters) }
-  def transform_values!; end
-
-  sig { returns(ActionController::Parameters) }
-  def transform_values; 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

data/sorbet/rbi/annotations/actionview.rbi

@@ -1,75 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This file was pulled from a central RBI files repository.
-# Please run `bin/tapioca annotations` to update it.
-
-module ActionView
-  TemplateError = T.type_alias { Template::Error }
-
-  class MissingTemplate < ActionView::ActionViewError
-    sig { returns(String) }
-    def path; end
-  end
-end
-
-class ActionView::Helpers::FormBuilder
-  sig { returns(T.untyped) }
-  def object; end
-end
-
-module ActionView::Helpers::NumberHelper
-  sig { params(number: T.untyped, options: T::Hash[T.untyped, T.untyped]).returns(T.nilable(String)) }
-  def number_to_currency(number, options = T.unsafe(nil)); end
-
-  sig { params(number: T.untyped, options: T::Hash[T.untyped, T.untyped]).returns(T.nilable(String)) }
-  def number_to_human(number, options = T.unsafe(nil)); end
-
-  sig { params(number: T.untyped, options: T::Hash[T.untyped, T.untyped]).returns(T.nilable(String)) }
-  def number_to_human_size(number, options = T.unsafe(nil)); end
-
-  sig { params(number: T.untyped, options: T::Hash[T.untyped, T.untyped]).returns(T.nilable(String)) }
-  def number_to_percentage(number, options = T.unsafe(nil)); end
-
-  sig { params(number: T.untyped, options: T::Hash[T.untyped, T.untyped]).returns(T.nilable(String)) }
-  def number_to_phone(number, options = T.unsafe(nil)); end
-
-  sig { params(number: T.untyped, options: T::Hash[T.untyped, T.untyped]).returns(T.nilable(String)) }
-  def number_with_delimiter(number, options = T.unsafe(nil)); end
-
-  sig { params(number: T.untyped, options: T::Hash[T.untyped, T.untyped]).returns(T.nilable(String)) }
-  def number_with_precision(number, options = T.unsafe(nil)); end
-end
-
-module ActionView::Helpers::SanitizeHelper
-  mixes_in_class_methods ActionView::Helpers::SanitizeHelper::ClassMethods
-end
-
-module ActionView::Helpers::UrlHelper
-  extend ActiveSupport::Concern
-  include ActionView::Helpers::TagHelper
-  mixes_in_class_methods ActionView::Helpers::UrlHelper::ClassMethods
-
-  sig { params(name: T.nilable(String), options: T.untyped, html_options: T.untyped, block: T.untyped).returns(ActiveSupport::SafeBuffer) }
-  def link_to(name = nil, options = nil, html_options = nil, &block); end
-
-  sig { params(condition: T.untyped, name: String, options: T.untyped, html_options: T.untyped, block: T.untyped).returns(T.untyped) }
-  def link_to_if(condition, name, options = {}, html_options = {}, &block); end
-end
-
-module ActionView::Layouts
-  mixes_in_class_methods ActionView::Layouts::ClassMethods
-end
-
-module ActionView::Rendering
-  mixes_in_class_methods ActionView::Rendering::ClassMethods
-end
-
-module ActionView::ViewPaths
-  mixes_in_class_methods ActionView::ViewPaths::ClassMethods
-end
-
-module ActionView::ViewPaths::ClassMethods
-  sig { params(value: T.any(String, T::Array[String])).void }
-  def append_view_path(value); end
-end