zuora_connect_ui 0.8.1 → 0.8.2

data/vendor/ruby/2.6.0/gems/railties-6.0.0/lib/rails/paths.rb

@@ -0,0 +1,237 @@
+# frozen_string_literal: true
+
+module Rails
+  module Paths
+    # This object is an extended hash that behaves as root of the <tt>Rails::Paths</tt> system.
+    # It allows you to collect information about how you want to structure your application
+    # paths through a Hash-like API. It requires you to give a physical path on initialization.
+    #
+    #   root = Root.new "/rails"
+    #   root.add "app/controllers", eager_load: true
+    #
+    # The above command creates a new root object and adds "app/controllers" as a path.
+    # This means we can get a <tt>Rails::Paths::Path</tt> object back like below:
+    #
+    #   path = root["app/controllers"]
+    #   path.eager_load?               # => true
+    #   path.is_a?(Rails::Paths::Path) # => true
+    #
+    # The +Path+ object is simply an enumerable and allows you to easily add extra paths:
+    #
+    #   path.is_a?(Enumerable) # => true
+    #   path.to_ary.inspect    # => ["app/controllers"]
+    #
+    #   path << "lib/controllers"
+    #   path.to_ary.inspect    # => ["app/controllers", "lib/controllers"]
+    #
+    # Notice that when you add a path using +add+, the path object created already
+    # contains the path with the same path value given to +add+. In some situations,
+    # you may not want this behavior, so you can give <tt>:with</tt> as option.
+    #
+    #   root.add "config/routes", with: "config/routes.rb"
+    #   root["config/routes"].inspect # => ["config/routes.rb"]
+    #
+    # The +add+ method accepts the following options as arguments:
+    # eager_load, autoload, autoload_once, and glob.
+    #
+    # Finally, the +Path+ object also provides a few helpers:
+    #
+    #   root = Root.new "/rails"
+    #   root.add "app/controllers"
+    #
+    #   root["app/controllers"].expanded # => ["/rails/app/controllers"]
+    #   root["app/controllers"].existent # => ["/rails/app/controllers"]
+    #
+    # Check the <tt>Rails::Paths::Path</tt> documentation for more information.
+    class Root
+      attr_accessor :path
+
+      def initialize(path)
+        @path = path
+        @root = {}
+      end
+
+      def []=(path, value)
+        glob = self[path] ? self[path].glob : nil
+        add(path, with: value, glob: glob)
+      end
+
+      def add(path, options = {})
+        with = Array(options.fetch(:with, path))
+        @root[path] = Path.new(self, path, with, options)
+      end
+
+      def [](path)
+        @root[path]
+      end
+
+      def values
+        @root.values
+      end
+
+      def keys
+        @root.keys
+      end
+
+      def values_at(*list)
+        @root.values_at(*list)
+      end
+
+      def all_paths
+        values.tap(&:uniq!)
+      end
+
+      def autoload_once
+        filter_by(&:autoload_once?)
+      end
+
+      def eager_load
+        filter_by(&:eager_load?)
+      end
+
+      def autoload_paths
+        filter_by(&:autoload?)
+      end
+
+      def load_paths
+        filter_by(&:load_path?)
+      end
+
+    private
+
+      def filter_by(&block)
+        all_paths.find_all(&block).flat_map { |path|
+          paths = path.existent
+          paths - path.children.flat_map { |p| yield(p) ? [] : p.existent }
+        }.uniq
+      end
+    end
+
+    class Path
+      include Enumerable
+
+      attr_accessor :glob
+
+      def initialize(root, current, paths, options = {})
+        @paths   = paths
+        @current = current
+        @root    = root
+        @glob    = options[:glob]
+        @exclude = options[:exclude]
+
+        options[:autoload_once] ? autoload_once! : skip_autoload_once!
+        options[:eager_load]    ? eager_load!    : skip_eager_load!
+        options[:autoload]      ? autoload!      : skip_autoload!
+        options[:load_path]     ? load_path!     : skip_load_path!
+      end
+
+      def absolute_current # :nodoc:
+        File.expand_path(@current, @root.path)
+      end
+
+      def children
+        keys = @root.keys.find_all { |k|
+          k.start_with?(@current) && k != @current
+        }
+        @root.values_at(*keys.sort)
+      end
+
+      def first
+        expanded.first
+      end
+
+      def last
+        expanded.last
+      end
+
+      %w(autoload_once eager_load autoload load_path).each do |m|
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{m}!        # def eager_load!
+            @#{m} = true   #   @eager_load = true
+          end              # end
+                           #
+          def skip_#{m}!   # def skip_eager_load!
+            @#{m} = false  #   @eager_load = false
+          end              # end
+                           #
+          def #{m}?        # def eager_load?
+            @#{m}          #   @eager_load
+          end              # end
+        RUBY
+      end
+
+      def each(&block)
+        @paths.each(&block)
+      end
+
+      def <<(path)
+        @paths << path
+      end
+      alias :push :<<
+
+      def concat(paths)
+        @paths.concat paths
+      end
+
+      def unshift(*paths)
+        @paths.unshift(*paths)
+      end
+
+      def to_ary
+        @paths
+      end
+
+      def extensions # :nodoc:
+        $1.split(",") if @glob =~ /\{([\S]+)\}/
+      end
+
+      # Expands all paths against the root and return all unique values.
+      def expanded
+        raise "You need to set a path root" unless @root.path
+        result = []
+
+        each do |path|
+          path = File.expand_path(path, @root.path)
+
+          if @glob && File.directory?(path)
+            result.concat files_in(path)
+          else
+            result << path
+          end
+        end
+
+        result.uniq!
+        result
+      end
+
+      # Returns all expanded paths but only if they exist in the filesystem.
+      def existent
+        expanded.select do |f|
+          does_exist = File.exist?(f)
+
+          if !does_exist && File.symlink?(f)
+            raise "File #{f.inspect} is a symlink that does not point to a valid file"
+          end
+          does_exist
+        end
+      end
+
+      def existent_directories
+        expanded.select { |d| File.directory?(d) }
+      end
+
+      alias to_a expanded
+
+      private
+
+        def files_in(path)
+          Dir.chdir(path) do
+            files = Dir.glob(@glob)
+            files -= @exclude if @exclude
+            files.map! { |file| File.join(path, file) }
+            files.sort
+          end
+        end
+    end
+  end
+end

data/vendor/ruby/2.6.0/gems/railties-6.0.0/lib/rails/plugin/test.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require "rails/test_unit/runner"
+require "rails/test_unit/reporter"
+
+Rails::TestUnitReporter.executable = "bin/test"
+
+Rails::TestUnit::Runner.parse_options(ARGV)
+Rails::TestUnit::Runner.run(ARGV)

data/vendor/ruby/2.6.0/gems/railties-6.0.0/lib/rails/rack/logger.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/time/conversions"
+require "active_support/core_ext/object/blank"
+require "active_support/log_subscriber"
+require "action_dispatch/http/request"
+require "rack/body_proxy"
+
+module Rails
+  module Rack
+    # Sets log tags, logs the request, calls the app, and flushes the logs.
+    #
+    # Log tags (+taggers+) can be an Array containing: methods that the +request+
+    # object responds to, objects that respond to +to_s+ or Proc objects that accept
+    # an instance of the +request+ object.
+    class Logger < ActiveSupport::LogSubscriber
+      def initialize(app, taggers = nil)
+        @app          = app
+        @taggers      = taggers || []
+      end
+
+      def call(env)
+        request = ActionDispatch::Request.new(env)
+
+        if logger.respond_to?(:tagged)
+          logger.tagged(compute_tags(request)) { call_app(request, env) }
+        else
+          call_app(request, env)
+        end
+      end
+
+      private
+
+        def call_app(request, env) # :doc:
+          instrumenter = ActiveSupport::Notifications.instrumenter
+          instrumenter.start "request.action_dispatch", request: request
+          logger.info { started_request_message(request) }
+          status, headers, body = @app.call(env)
+          body = ::Rack::BodyProxy.new(body) { finish(request) }
+          [status, headers, body]
+        rescue Exception
+          finish(request)
+          raise
+        ensure
+          ActiveSupport::LogSubscriber.flush_all!
+        end
+
+        # Started GET "/session/new" for 127.0.0.1 at 2012-09-26 14:51:42 -0700
+        def started_request_message(request) # :doc:
+          'Started %s "%s" for %s at %s' % [
+            request.request_method,
+            request.filtered_path,
+            request.remote_ip,
+            Time.now.to_default_s ]
+        end
+
+        def compute_tags(request) # :doc:
+          @taggers.collect do |tag|
+            case tag
+            when Proc
+              tag.call(request)
+            when Symbol
+              request.send(tag)
+            else
+              tag
+            end
+          end
+        end
+
+        def finish(request)
+          instrumenter = ActiveSupport::Notifications.instrumenter
+          instrumenter.finish "request.action_dispatch", request: request
+        end
+
+        def logger
+          Rails.logger
+        end
+    end
+  end
+end

data/vendor/ruby/2.6.0/gems/railties-6.0.0/lib/rails/rack.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Rails
+  module Rack
+    autoload :Logger, "rails/rack/logger"
+  end
+end

data/vendor/ruby/2.6.0/gems/railties-6.0.0/lib/rails/railtie/configurable.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Rails
+  class Railtie
+    module Configurable
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        delegate :config, to: :instance
+
+        def inherited(base)
+          raise "You cannot inherit from a #{superclass.name} child"
+        end
+
+        def instance
+          @instance ||= new
+        end
+
+        def respond_to?(*args)
+          super || instance.respond_to?(*args)
+        end
+
+        def configure(&block)
+          class_eval(&block)
+        end
+
+        private
+
+          def method_missing(*args, &block)
+            instance.send(*args, &block)
+          end
+      end
+    end
+  end
+end

data/vendor/ruby/2.6.0/gems/railties-6.0.0/lib/rails/railtie/configuration.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require "rails/configuration"
+
+module Rails
+  class Railtie
+    class Configuration
+      def initialize
+        @@options ||= {}
+      end
+
+      # Expose the eager_load_namespaces at "module" level for convenience.
+      def self.eager_load_namespaces #:nodoc:
+        @@eager_load_namespaces ||= []
+      end
+
+      # All namespaces that are eager loaded
+      def eager_load_namespaces
+        @@eager_load_namespaces ||= []
+      end
+
+      # Add files that should be watched for change.
+      def watchable_files
+        @@watchable_files ||= []
+      end
+
+      # Add directories that should be watched for change.
+      # The key of the hashes should be directories and the values should
+      # be an array of extensions to match in each directory.
+      def watchable_dirs
+        @@watchable_dirs ||= {}
+      end
+
+      # This allows you to modify the application's middlewares from Engines.
+      #
+      # All operations you run on the app_middleware will be replayed on the
+      # application once it is defined and the default_middlewares are
+      # created
+      def app_middleware
+        @@app_middleware ||= Rails::Configuration::MiddlewareStackProxy.new
+      end
+
+      # This allows you to modify application's generators from Railties.
+      #
+      # Values set on app_generators will become defaults for application, unless
+      # application overwrites them.
+      def app_generators
+        @@app_generators ||= Rails::Configuration::Generators.new
+        yield(@@app_generators) if block_given?
+        @@app_generators
+      end
+
+      # First configurable block to run. Called before any initializers are run.
+      def before_configuration(&block)
+        ActiveSupport.on_load(:before_configuration, yield: true, &block)
+      end
+
+      # Third configurable block to run. Does not run if +config.eager_load+
+      # set to false.
+      def before_eager_load(&block)
+        ActiveSupport.on_load(:before_eager_load, yield: true, &block)
+      end
+
+      # Second configurable block to run. Called before frameworks initialize.
+      def before_initialize(&block)
+        ActiveSupport.on_load(:before_initialize, yield: true, &block)
+      end
+
+      # Last configurable block to run. Called after frameworks initialize.
+      def after_initialize(&block)
+        ActiveSupport.on_load(:after_initialize, yield: true, &block)
+      end
+
+      # Array of callbacks defined by #to_prepare.
+      def to_prepare_blocks
+        @@to_prepare_blocks ||= []
+      end
+
+      # Defines generic callbacks to run before #after_initialize. Useful for
+      # Rails::Railtie subclasses.
+      def to_prepare(&blk)
+        to_prepare_blocks << blk if blk
+      end
+
+      def respond_to?(name, include_private = false)
+        super || @@options.key?(name.to_sym)
+      end
+
+    private
+
+      def method_missing(name, *args, &blk)
+        if name.to_s =~ /=$/
+          @@options[$`.to_sym] = args.first
+        elsif @@options.key?(name)
+          @@options[name]
+        else
+          super
+        end
+      end
+    end
+  end
+end