jets 1.9.7 → 1.9.8

data/vendor/rails/actionpack/MIT-LICENSE

@@ -1,21 +0,0 @@
-Copyright (c) 2004-2018 David Heinemeier Hansson
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-

data/vendor/rails/actionpack/README.rdoc

@@ -1,57 +0,0 @@
-= Action Pack -- From request to response
-
-Action Pack is a framework for handling and responding to web requests. It
-provides mechanisms for *routing* (mapping request URLs to actions), defining
-*controllers* that implement actions, and generating responses by rendering
-*views*, which are templates of various formats. In short, Action Pack
-provides the view and controller layers in the MVC paradigm.
-
-It consists of several modules:
-
-* Action Dispatch, which parses information about the web request, handles
-  routing as defined by the user, and does advanced processing related to HTTP
-  such as MIME-type negotiation, decoding parameters in POST, PATCH, or PUT bodies,
-  handling HTTP caching logic, cookies and sessions.
-
-* Action Controller, which provides a base controller class that can be
-  subclassed to implement filters and actions to handle requests. The result
-  of an action is typically content generated from views.
-
-With the Ruby on Rails framework, users only directly interface with the
-Action Controller module. Necessary Action Dispatch functionality is activated
-by default and Action View rendering is implicitly triggered by Action
-Controller. However, these modules are designed to function on their own and
-can be used outside of Rails.
-
-
-== Download and installation
-
-The latest version of Action Pack can be installed with RubyGems:
-
-  $ gem install actionpack
-
-Source code can be downloaded as part of the Rails project on GitHub:
-
-* https://github.com/rails/rails/tree/5-2-stable/actionpack
-
-
-== License
-
-Action Pack is released under the MIT license:
-
-* https://opensource.org/licenses/MIT
-
-
-== Support
-
-API documentation is at:
-
-* http://api.rubyonrails.org
-
-Bug reports for the Ruby on Rails project can be filed here:
-
-* https://github.com/rails/rails/issues
-
-Feature requests should be discussed on the rails-core mailing list here:
-
-* https://groups.google.com/forum/?fromgroups#!forum/rubyonrails-core

data/vendor/rails/actionpack/Rakefile

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-require "rake/testtask"
-
-test_files = Dir.glob("test/**/*_test.rb")
-
-desc "Default Task"
-task default: :test
-
-task :package
-
-# Run the unit tests
-Rake::TestTask.new do |t|
-  t.libs << "test"
-  t.test_files = test_files
-
-  t.warning = true
-  t.verbose = true
-  t.ruby_opts = ["--dev"] if defined?(JRUBY_VERSION)
-end
-
-namespace :test do
-  task :isolated do
-    test_files.all? do |file|
-      sh(Gem.ruby, "-w", "-Ilib:test", file)
-    end || raise("Failures")
-  end
-end
-
-task :lines do
-  load File.expand_path("..", __dir__) + "/tools/line_statistics"
-  files = FileList["lib/**/*.rb"]
-  CodeTools::LineStatistics.new(files).print_loc
-end
-
-rule ".rb" => ".y" do |t|
-  sh "racc -l -o #{t.name} #{t.source}"
-end
-
-task compile: "lib/action_dispatch/journey/parser.rb"

data/vendor/rails/actionpack/actionpack.gemspec

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-version = File.read(File.expand_path("../RAILS_VERSION", __dir__)).strip
-
-Gem::Specification.new do |s|
-  s.platform    = Gem::Platform::RUBY
-  s.name        = "actionpack"
-  s.version     = version
-  s.summary     = "Web-flow and rendering framework putting the VC in MVC (part of Rails)."
-  s.description = "Web apps on Rails. Simple, battle-tested conventions for building and testing MVC web applications. Works with any Rack-compatible server."
-
-  s.required_ruby_version = ">= 2.2.2"
-
-  s.license = "MIT"
-
-  s.author   = "David Heinemeier Hansson"
-  s.email    = "david@loudthinking.com"
-  s.homepage = "http://rubyonrails.org"
-
-  s.files        = Dir["CHANGELOG.md", "README.rdoc", "MIT-LICENSE", "lib/**/*"]
-  s.require_path = "lib"
-  s.requirements << "none"
-
-  s.metadata = {
-    "source_code_uri" => "https://github.com/rails/rails/tree/v#{version}/actionpack",
-    "changelog_uri"   => "https://github.com/rails/rails/blob/v#{version}/actionpack/CHANGELOG.md"
-  }
-
-  s.add_dependency "activesupport", version
-
-  s.add_dependency "rack",      "~> 2.0"
-  s.add_dependency "rack-test", ">= 0.6.3"
-  s.add_dependency "rails-html-sanitizer", "~> 1.0", ">= 1.0.2"
-  s.add_dependency "rails-dom-testing", "~> 2.0"
-  s.add_dependency "actionview", version
-
-  s.add_development_dependency "activemodel", version
-end

data/vendor/rails/actionpack/bin/test

@@ -1,5 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-COMPONENT_ROOT = File.expand_path("..", __dir__)
-require_relative "../../tools/test"

data/vendor/rails/actionpack/lib/abstract_controller.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-require "action_pack"
-require "active_support/rails"
-require "active_support/i18n"
-
-module AbstractController
-  extend ActiveSupport::Autoload
-
-  autoload :ActionNotFound, "abstract_controller/base"
-  autoload :Base
-  autoload :Caching
-  autoload :Callbacks
-  autoload :Collector
-  autoload :DoubleRenderError, "abstract_controller/rendering"
-  autoload :Helpers
-  autoload :Logger
-  autoload :Rendering
-  autoload :Translation
-  autoload :AssetPaths
-  autoload :UrlFor
-
-  def self.eager_load!
-    super
-    AbstractController::Caching.eager_load!
-  end
-end

data/vendor/rails/actionpack/lib/abstract_controller/asset_paths.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-module AbstractController
-  module AssetPaths #:nodoc:
-    extend ActiveSupport::Concern
-
-    included do
-      config_accessor :asset_host, :assets_dir, :javascripts_dir,
-        :stylesheets_dir, :default_asset_host_protocol, :relative_url_root
-    end
-  end
-end

data/vendor/rails/actionpack/lib/abstract_controller/base.rb

@@ -1,265 +0,0 @@
-# frozen_string_literal: true
-
-require "abstract_controller/error"
-require "active_support/configurable"
-require "active_support/descendants_tracker"
-require "active_support/core_ext/module/anonymous"
-require "active_support/core_ext/module/attr_internal"
-
-module AbstractController
-  # Raised when a non-existing controller action is triggered.
-  class ActionNotFound < StandardError
-  end
-
-  # AbstractController::Base is a low-level API. Nobody should be
-  # using it directly, and subclasses (like ActionController::Base) are
-  # expected to provide their own +render+ method, since rendering means
-  # different things depending on the context.
-  class Base
-    ##
-    # Returns the body of the HTTP response sent by the controller.
-    attr_internal :response_body
-
-    ##
-    # Returns the name of the action this controller is processing.
-    attr_internal :action_name
-
-    ##
-    # Returns the formats that can be processed by the controller.
-    attr_internal :formats
-
-    include ActiveSupport::Configurable
-    extend ActiveSupport::DescendantsTracker
-
-    class << self
-      attr_reader :abstract
-      alias_method :abstract?, :abstract
-
-      # Define a controller as abstract. See internal_methods for more
-      # details.
-      def abstract!
-        @abstract = true
-      end
-
-      def inherited(klass) # :nodoc:
-        # Define the abstract ivar on subclasses so that we don't get
-        # uninitialized ivar warnings
-        unless klass.instance_variable_defined?(:@abstract)
-          klass.instance_variable_set(:@abstract, false)
-        end
-        super
-      end
-
-      # A list of all internal methods for a controller. This finds the first
-      # abstract superclass of a controller, and gets a list of all public
-      # instance methods on that abstract class. Public instance methods of
-      # a controller would normally be considered action methods, so methods
-      # declared on abstract classes are being removed.
-      # (<tt>ActionController::Metal</tt> and ActionController::Base are defined as abstract)
-      def internal_methods
-        controller = self
-
-        controller = controller.superclass until controller.abstract?
-        controller.public_instance_methods(true)
-      end
-
-      # A list of method names that should be considered actions. This
-      # includes all public instance methods on a controller, less
-      # any internal methods (see internal_methods), adding back in
-      # any methods that are internal, but still exist on the class
-      # itself.
-      #
-      # ==== Returns
-      # * <tt>Set</tt> - A set of all methods that should be considered actions.
-      def action_methods
-        @action_methods ||= begin
-          # All public instance methods of this class, including ancestors
-          methods = (public_instance_methods(true) -
-            # Except for public instance methods of Base and its ancestors
-            internal_methods +
-            # Be sure to include shadowed public instance methods of this class
-            public_instance_methods(false)).uniq.map(&:to_s)
-
-          methods.to_set
-        end
-      end
-
-      # action_methods are cached and there is sometimes a need to refresh
-      # them. ::clear_action_methods! allows you to do that, so next time
-      # you run action_methods, they will be recalculated.
-      def clear_action_methods!
-        @action_methods = nil
-      end
-
-      # Returns the full controller name, underscored, without the ending Controller.
-      #
-      #   class MyApp::MyPostsController < AbstractController::Base
-      #
-      #   end
-      #
-      #   MyApp::MyPostsController.controller_path # => "my_app/my_posts"
-      #
-      # ==== Returns
-      # * <tt>String</tt>
-      def controller_path
-        @controller_path ||= name.sub(/Controller$/, "".freeze).underscore unless anonymous?
-      end
-
-      # Refresh the cached action_methods when a new action_method is added.
-      def method_added(name)
-        super
-        clear_action_methods!
-      end
-    end
-
-    abstract!
-
-    # Calls the action going through the entire action dispatch stack.
-    #
-    # The actual method that is called is determined by calling
-    # #method_for_action. If no method can handle the action, then an
-    # AbstractController::ActionNotFound error is raised.
-    #
-    # ==== Returns
-    # * <tt>self</tt>
-    def process(action, *args)
-      @_action_name = action.to_s
-
-      unless action_name = _find_action_name(@_action_name)
-        raise ActionNotFound, "The action '#{action}' could not be found for #{self.class.name}"
-      end
-
-      @_response_body = nil
-
-      process_action(action_name, *args)
-    end
-
-    # Delegates to the class' ::controller_path
-    def controller_path
-      self.class.controller_path
-    end
-
-    # Delegates to the class' ::action_methods
-    def action_methods
-      self.class.action_methods
-    end
-
-    # Returns true if a method for the action is available and
-    # can be dispatched, false otherwise.
-    #
-    # Notice that <tt>action_methods.include?("foo")</tt> may return
-    # false and <tt>available_action?("foo")</tt> returns true because
-    # this method considers actions that are also available
-    # through other means, for example, implicit render ones.
-    #
-    # ==== Parameters
-    # * <tt>action_name</tt> - The name of an action to be tested
-    def available_action?(action_name)
-      _find_action_name(action_name)
-    end
-
-    # Tests if a response body is set. Used to determine if the
-    # +process_action+ callback needs to be terminated in
-    # +AbstractController::Callbacks+.
-    def performed?
-      response_body
-    end
-
-    # Returns true if the given controller is capable of rendering
-    # a path. A subclass of +AbstractController::Base+
-    # may return false. An Email controller for example does not
-    # support paths, only full URLs.
-    def self.supports_path?
-      true
-    end
-
-    private
-
-      # Returns true if the name can be considered an action because
-      # it has a method defined in the controller.
-      #
-      # ==== Parameters
-      # * <tt>name</tt> - The name of an action to be tested
-      def action_method?(name)
-        self.class.action_methods.include?(name)
-      end
-
-      # Call the action. Override this in a subclass to modify the
-      # behavior around processing an action. This, and not #process,
-      # is the intended way to override action dispatching.
-      #
-      # Notice that the first argument is the method to be dispatched
-      # which is *not* necessarily the same as the action name.
-      def process_action(method_name, *args)
-        send_action(method_name, *args)
-      end
-
-      # Actually call the method associated with the action. Override
-      # this method if you wish to change how action methods are called,
-      # not to add additional behavior around it. For example, you would
-      # override #send_action if you want to inject arguments into the
-      # method.
-      alias send_action send
-
-      # If the action name was not found, but a method called "action_missing"
-      # was found, #method_for_action will return "_handle_action_missing".
-      # This method calls #action_missing with the current action name.
-      def _handle_action_missing(*args)
-        action_missing(@_action_name, *args)
-      end
-
-      # Takes an action name and returns the name of the method that will
-      # handle the action.
-      #
-      # It checks if the action name is valid and returns false otherwise.
-      #
-      # See method_for_action for more information.
-      #
-      # ==== Parameters
-      # * <tt>action_name</tt> - An action name to find a method name for
-      #
-      # ==== Returns
-      # * <tt>string</tt> - The name of the method that handles the action
-      # * false           - No valid method name could be found.
-      # Raise +AbstractController::ActionNotFound+.
-      def _find_action_name(action_name)
-        _valid_action_name?(action_name) && method_for_action(action_name)
-      end
-
-      # Takes an action name and returns the name of the method that will
-      # handle the action. In normal cases, this method returns the same
-      # name as it receives. By default, if #method_for_action receives
-      # a name that is not an action, it will look for an #action_missing
-      # method and return "_handle_action_missing" if one is found.
-      #
-      # Subclasses may override this method to add additional conditions
-      # that should be considered an action. For instance, an HTTP controller
-      # with a template matching the action name is considered to exist.
-      #
-      # If you override this method to handle additional cases, you may
-      # also provide a method (like +_handle_method_missing+) to handle
-      # the case.
-      #
-      # If none of these conditions are true, and +method_for_action+
-      # returns +nil+, an +AbstractController::ActionNotFound+ exception will be raised.
-      #
-      # ==== Parameters
-      # * <tt>action_name</tt> - An action name to find a method name for
-      #
-      # ==== Returns
-      # * <tt>string</tt> - The name of the method that handles the action
-      # * <tt>nil</tt>    - No method name could be found.
-      def method_for_action(action_name)
-        if action_method?(action_name)
-          action_name
-        elsif respond_to?(:action_missing, true)
-          "_handle_action_missing"
-        end
-      end
-
-      # Checks if the action name is valid and returns false otherwise.
-      def _valid_action_name?(action_name)
-        !action_name.to_s.include? File::SEPARATOR
-      end
-  end
-end