brakeman 4.4.0 → 5.0.0

data/bundle/ruby/2.5.0/gems/sass-3.4.25/lib/sass/features.rb

@@ -1,47 +0,0 @@
-require 'set'
-module Sass
-  # Provides `Sass.has_feature?` which allows for simple feature detection
-  # by providing a feature name.
-  module Features
-    # This is the set of features that can be detected.
-    #
-    # When this is updated, the documentation of `feature-exists()` should be
-    # updated as well.
-    KNOWN_FEATURES = Set[*%w(
-      global-variable-shadowing
-      extend-selector-pseudoclass
-      units-level-3
-      at-error
-    )]
-
-    # Check if a feature exists by name. This is used to implement
-    # the Sass function `feature-exists($feature)`
-    #
-    # @param feature_name [String] The case sensitive name of the feature to
-    #   check if it exists in this version of Sass.
-    # @return [Boolean] whether the feature of that name exists.
-    def has_feature?(feature_name)
-      KNOWN_FEATURES.include?(feature_name)
-    end
-
-    # Add a feature to Sass. Plugins can use this to easily expose their
-    # availability to end users. Plugins must prefix their feature
-    # names with a dash to distinguish them from official features.
-    #
-    # @example
-    #   Sass.add_feature("-import-globbing")
-    #   Sass.add_feature("-math-cos")
-    #
-    #
-    # @param feature_name [String] The case sensitive name of the feature to
-    #   to add to Sass. Must begin with a dash.
-    def add_feature(feature_name)
-      unless feature_name[0] == ?-
-        raise ArgumentError.new("Plugin feature names must begin with a dash")
-      end
-      KNOWN_FEATURES << feature_name
-    end
-  end
-
-  extend Features
-end

data/bundle/ruby/2.5.0/gems/sass-3.4.25/lib/sass/importers.rb

@@ -1,23 +0,0 @@
-module Sass
-  # Sass importers are in charge of taking paths passed to `@import`
-  # and finding the appropriate Sass code for those paths.
-  # By default, this code is always loaded from the filesystem,
-  # but importers could be added to load from a database or over HTTP.
-  #
-  # Each importer is in charge of a single load path
-  # (or whatever the corresponding notion is for the backend).
-  # Importers can be placed in the {file:SASS_REFERENCE.md#load_paths-option `:load_paths` array}
-  # alongside normal filesystem paths.
-  #
-  # When resolving an `@import`, Sass will go through the load paths
-  # looking for an importer that successfully imports the path.
-  # Once one is found, the imported file is used.
-  #
-  # User-created importers must inherit from {Importers::Base}.
-  module Importers
-  end
-end
-
-require 'sass/importers/base'
-require 'sass/importers/filesystem'
-require 'sass/importers/deprecated_path'

data/bundle/ruby/2.5.0/gems/sass-3.4.25/lib/sass/importers/base.rb

@@ -1,182 +0,0 @@
-module Sass
-  module Importers
-    # The abstract base class for Sass importers.
-    # All importers should inherit from this.
-    #
-    # At the most basic level, an importer is given a string
-    # and must return a {Sass::Engine} containing some Sass code.
-    # This string can be interpreted however the importer wants;
-    # however, subclasses are encouraged to use the URI format
-    # for pathnames.
-    #
-    # Importers that have some notion of "relative imports"
-    # should take a single load path in their constructor,
-    # and interpret paths as relative to that.
-    # They should also implement the \{#find\_relative} method.
-    #
-    # Importers should be serializable via `Marshal.dump`.
-    #
-    # @abstract
-    class Base
-      # Find a Sass file relative to another file.
-      # Importers without a notion of "relative paths"
-      # should just return nil here.
-      #
-      # If the importer does have a notion of "relative paths",
-      # it should ignore its load path during this method.
-      #
-      # See \{#find} for important information on how this method should behave.
-      #
-      # The `:filename` option passed to the returned {Sass::Engine}
-      # should be of a format that could be passed to \{#find}.
-      #
-      # @param uri [String] The URI to import. This is not necessarily relative,
-      #   but this method should only return true if it is.
-      # @param base [String] The base filename. If `uri` is relative,
-      #   it should be interpreted as relative to `base`.
-      #   `base` is guaranteed to be in a format importable by this importer.
-      # @param options [{Symbol => Object}] Options for the Sass file
-      #   containing the `@import` that's currently being resolved.
-      # @return [Sass::Engine, nil] An Engine containing the imported file,
-      #   or nil if it couldn't be found or was in the wrong format.
-      def find_relative(uri, base, options)
-        Sass::Util.abstract(self)
-      end
-
-      # Find a Sass file, if it exists.
-      #
-      # This is the primary entry point of the Importer.
-      # It corresponds directly to an `@import` statement in Sass.
-      # It should do three basic things:
-      #
-      # * Determine if the URI is in this importer's format.
-      #   If not, return nil.
-      # * Determine if the file indicated by the URI actually exists and is readable.
-      #   If not, return nil.
-      # * Read the file and place the contents in a {Sass::Engine}.
-      #   Return that engine.
-      #
-      # If this importer's format allows for file extensions,
-      # it should treat them the same way as the default {Filesystem} importer.
-      # If the URI explicitly has a `.sass` or `.scss` filename,
-      # the importer should look for that exact file
-      # and import it as the syntax indicated.
-      # If it doesn't exist, the importer should return nil.
-      #
-      # If the URI doesn't have either of these extensions,
-      # the importer should look for files with the extensions.
-      # If no such files exist, it should return nil.
-      #
-      # The {Sass::Engine} to be returned should be passed `options`,
-      # with a few modifications. `:syntax` should be set appropriately,
-      # `:filename` should be set to `uri`,
-      # and `:importer` should be set to this importer.
-      #
-      # @param uri [String] The URI to import.
-      # @param options [{Symbol => Object}] Options for the Sass file
-      #   containing the `@import` that's currently being resolved.
-      #   This is safe for subclasses to modify destructively.
-      #   Callers should only pass in a value they don't mind being destructively modified.
-      # @return [Sass::Engine, nil] An Engine containing the imported file,
-      #   or nil if it couldn't be found or was in the wrong format.
-      def find(uri, options)
-        Sass::Util.abstract(self)
-      end
-
-      # Returns the time the given Sass file was last modified.
-      #
-      # If the given file has been deleted or the time can't be accessed
-      # for some other reason, this should return nil.
-      #
-      # @param uri [String] The URI of the file to check.
-      #   Comes from a `:filename` option set on an engine returned by this importer.
-      # @param options [{Symbol => Object}] Options for the Sass file
-      #   containing the `@import` currently being checked.
-      # @return [Time, nil]
-      def mtime(uri, options)
-        Sass::Util.abstract(self)
-      end
-
-      # Get the cache key pair for the given Sass URI.
-      # The URI need not be checked for validity.
-      #
-      # The only strict requirement is that the returned pair of strings
-      # uniquely identify the file at the given URI.
-      # However, the first component generally corresponds roughly to the directory,
-      # and the second to the basename, of the URI.
-      #
-      # Note that keys must be unique *across importers*.
-      # Thus it's probably a good idea to include the importer name
-      # at the beginning of the first component.
-      #
-      # @param uri [String] A URI known to be valid for this importer.
-      # @param options [{Symbol => Object}] Options for the Sass file
-      #   containing the `@import` currently being checked.
-      # @return [(String, String)] The key pair which uniquely identifies
-      #   the file at the given URI.
-      def key(uri, options)
-        Sass::Util.abstract(self)
-      end
-
-      # Get the publicly-visible URL for an imported file. This URL is used by
-      # source maps to link to the source stylesheet. This may return `nil` to
-      # indicate that no public URL is available; however, this will cause
-      # sourcemap generation to fail if any CSS is generated from files imported
-      # from this importer.
-      #
-      # If an absolute "file:" URI can be produced for an imported file, that
-      # should be preferred to returning `nil`. However, a URL relative to
-      # `sourcemap_directory` should be preferred over an absolute "file:" URI.
-      #
-      # @param uri [String] A URI known to be valid for this importer.
-      # @param sourcemap_directory [String, NilClass] The absolute path to a
-      #   directory on disk where the sourcemap will be saved. If uri refers to
-      #   a file on disk that's accessible relative to sourcemap_directory, this
-      #   may return a relative URL. This may be `nil` if the sourcemap's
-      #   eventual location is unknown.
-      # @return [String?] The publicly-visible URL for this file, or `nil`
-      #   indicating that no publicly-visible URL exists. This should be
-      #   appropriately URL-escaped.
-      def public_url(uri, sourcemap_directory)
-        return if @public_url_warning_issued
-        @public_url_warning_issued = true
-        Sass::Util.sass_warn <<WARNING
-WARNING: #{self.class.name} should define the #public_url method.
-WARNING
-        nil
-      end
-
-      # A string representation of the importer.
-      # Should be overridden by subclasses.
-      #
-      # This is used to help debugging,
-      # and should usually just show the load path encapsulated by this importer.
-      #
-      # @return [String]
-      def to_s
-        Sass::Util.abstract(self)
-      end
-
-      # If the importer is based on files on the local filesystem
-      # this method should return folders which should be watched
-      # for changes.
-      #
-      # @return [Array<String>] List of absolute paths of directories to watch
-      def directories_to_watch
-        []
-      end
-
-      # If this importer is based on files on the local filesystem This method
-      # should return true if the file, when changed, should trigger a
-      # recompile.
-      #
-      # It is acceptable for non-sass files to be watched and trigger a recompile.
-      #
-      # @param filename [String] The absolute filename for a file that has changed.
-      # @return [Boolean] When the file changed should cause a recompile.
-      def watched_file?(filename)
-        false
-      end
-    end
-  end
-end

data/bundle/ruby/2.5.0/gems/sass-3.4.25/lib/sass/importers/deprecated_path.rb

@@ -1,51 +0,0 @@
-module Sass
-  module Importers
-    # This importer emits a deprecation warning the first time it is used to
-    # import a file. It is used to deprecate the current working
-    # directory from the list of automatic sass load paths.
-    class DeprecatedPath < Filesystem
-      # @param root [String] The absolute, expanded path to the folder that is deprecated.
-      def initialize(root)
-        @specified_root = root
-        @warning_given = false
-        super
-      end
-
-      # @see Sass::Importers::Base#find
-      def find(*args)
-        found = super
-        if found && !@warning_given
-          @warning_given = true
-          Sass::Util.sass_warn deprecation_warning
-        end
-        found
-      end
-
-      # @see Base#directories_to_watch
-      def directories_to_watch
-        # The current working directory was not watched in Sass 3.2,
-        # so we continue not to watch it while it's deprecated.
-        []
-      end
-
-      # @see Sass::Importers::Base#to_s
-      def to_s
-        "#{@root} (DEPRECATED)"
-      end
-
-      protected
-
-      # @return [String] The deprecation warning that will be printed the first
-      #   time an import occurs.
-      def deprecation_warning
-        path = @specified_root == "." ? "the current working directory" : @specified_root
-        <<WARNING
-DEPRECATION WARNING: Importing from #{path} will not be
-automatic in future versions of Sass.  To avoid future errors, you can add it
-to your environment explicitly by setting `SASS_PATH=#{@specified_root}`, by using the -I command
-line option, or by changing your Sass configuration options.
-WARNING
-      end
-    end
-  end
-end

data/bundle/ruby/2.5.0/gems/sass-3.4.25/lib/sass/importers/filesystem.rb

@@ -1,219 +0,0 @@
-require 'set'
-
-module Sass
-  module Importers
-    # The default importer, used for any strings found in the load path.
-    # Simply loads Sass files from the filesystem using the default logic.
-    class Filesystem < Base
-      attr_accessor :root
-
-      # Creates a new filesystem importer that imports files relative to a given path.
-      #
-      # @param root [String] The root path.
-      #   This importer will import files relative to this path.
-      def initialize(root)
-        @root = File.expand_path(root)
-        @real_root = Sass::Util.realpath(@root).to_s
-        @same_name_warnings = Set.new
-      end
-
-      # @see Base#find_relative
-      def find_relative(name, base, options)
-        _find(File.dirname(base), name, options)
-      end
-
-      # @see Base#find
-      def find(name, options)
-        _find(@root, name, options)
-      end
-
-      # @see Base#mtime
-      def mtime(name, options)
-        file, _ = Sass::Util.destructure(find_real_file(@root, name, options))
-        File.mtime(file) if file
-      rescue Errno::ENOENT
-        nil
-      end
-
-      # @see Base#key
-      def key(name, options)
-        [self.class.name + ":" + File.dirname(File.expand_path(name)),
-         File.basename(name)]
-      end
-
-      # @see Base#to_s
-      def to_s
-        @root
-      end
-
-      def hash
-        @root.hash
-      end
-
-      def eql?(other)
-        !other.nil? && other.respond_to?(:root) && root.eql?(other.root)
-      end
-
-      # @see Base#directories_to_watch
-      def directories_to_watch
-        [root]
-      end
-
-      # @see Base#watched_file?
-      def watched_file?(filename)
-        # Check against the root with symlinks resolved, since Listen
-        # returns fully-resolved paths.
-        filename =~ /\.s[ac]ss$/ && filename.start_with?(@real_root + File::SEPARATOR)
-      end
-
-      def public_url(name, sourcemap_directory)
-        file_pathname = Sass::Util.cleanpath(Sass::Util.absolute_path(name, @root))
-        return Sass::Util.file_uri_from_path(file_pathname) if sourcemap_directory.nil?
-
-        sourcemap_pathname = Sass::Util.cleanpath(sourcemap_directory)
-        begin
-          Sass::Util.file_uri_from_path(
-            Sass::Util.relative_path_from(file_pathname, sourcemap_pathname))
-        rescue ArgumentError # when a relative path cannot be constructed
-          Sass::Util.file_uri_from_path(file_pathname)
-        end
-      end
-
-      protected
-
-      # If a full uri is passed, this removes the root from it
-      # otherwise returns the name unchanged
-      def remove_root(name)
-        if name.index(@root + "/") == 0
-          name[(@root.length + 1)..-1]
-        else
-          name
-        end
-      end
-
-      # A hash from file extensions to the syntaxes for those extensions.
-      # The syntaxes must be `:sass` or `:scss`.
-      #
-      # This can be overridden by subclasses that want normal filesystem importing
-      # with unusual extensions.
-      #
-      # @return [{String => Symbol}]
-      def extensions
-        {'sass' => :sass, 'scss' => :scss}
-      end
-
-      # Given an `@import`ed path, returns an array of possible
-      # on-disk filenames and their corresponding syntaxes for that path.
-      #
-      # @param name [String] The filename.
-      # @return [Array(String, Symbol)] An array of pairs.
-      #   The first element of each pair is a filename to look for;
-      #   the second element is the syntax that file would be in (`:sass` or `:scss`).
-      def possible_files(name)
-        name = escape_glob_characters(name)
-        dirname, basename, extname = split(name)
-        sorted_exts = extensions.sort
-        syntax = extensions[extname]
-
-        if syntax
-          ret = [["#{dirname}/{_,}#{basename}.#{extensions.invert[syntax]}", syntax]]
-        else
-          ret = sorted_exts.map {|ext, syn| ["#{dirname}/{_,}#{basename}.#{ext}", syn]}
-        end
-
-        # JRuby chokes when trying to import files from JARs when the path starts with './'.
-        ret.map {|f, s| [f.sub(%r{^\./}, ''), s]}
-      end
-
-      def escape_glob_characters(name)
-        name.gsub(/[\*\[\]\{\}\?]/) do |char|
-          "\\#{char}"
-        end
-      end
-
-      REDUNDANT_DIRECTORY = /#{Regexp.escape(File::SEPARATOR)}\.#{Regexp.escape(File::SEPARATOR)}/
-      # Given a base directory and an `@import`ed name,
-      # finds an existant file that matches the name.
-      #
-      # @param dir [String] The directory relative to which to search.
-      # @param name [String] The filename to search for.
-      # @return [(String, Symbol)] A filename-syntax pair.
-      def find_real_file(dir, name, options)
-        # On windows 'dir' or 'name' can be in native File::ALT_SEPARATOR form.
-        dir = dir.gsub(File::ALT_SEPARATOR, File::SEPARATOR) unless File::ALT_SEPARATOR.nil?
-        name = name.gsub(File::ALT_SEPARATOR, File::SEPARATOR) unless File::ALT_SEPARATOR.nil?
-
-        found = possible_files(remove_root(name)).map do |f, s|
-          path = if dir == "." || Sass::Util.pathname(f).absolute?
-                   f
-                 else
-                   "#{escape_glob_characters(dir)}/#{f}"
-                 end
-          Dir[path].map do |full_path|
-            full_path.gsub!(REDUNDANT_DIRECTORY, File::SEPARATOR)
-            [Sass::Util.cleanpath(full_path).to_s, s]
-          end
-        end.flatten(1)
-        return if found.empty?
-
-        if found.size > 1 && !@same_name_warnings.include?(found.first.first)
-          found.each {|(f, _)| @same_name_warnings << f}
-          relative_to = Sass::Util.pathname(dir)
-          if options[:_from_import_node]
-            # If _line exists, we're here due to an actual import in an
-            # import_node and we want to print a warning for a user writing an
-            # ambiguous import.
-            candidates = found.map do |(f, _)|
-              "  " + Sass::Util.pathname(f).relative_path_from(relative_to).to_s
-            end.join("\n")
-            raise Sass::SyntaxError.new(<<MESSAGE)
-It's not clear which file to import for '@import "#{name}"'.
-Candidates:
-#{candidates}
-Please delete or rename all but one of these files.
-MESSAGE
-          else
-            # Otherwise, we're here via StalenessChecker, and we want to print a
-            # warning for a user running `sass --watch` with two ambiguous files.
-            candidates = found.map {|(f, _)| "    " + File.basename(f)}.join("\n")
-            Sass::Util.sass_warn <<WARNING
-WARNING: In #{File.dirname(name)}:
-  There are multiple files that match the name "#{File.basename(name)}":
-#{candidates}
-WARNING
-          end
-        end
-        found.first
-      end
-
-      # Splits a filename into three parts, a directory part, a basename, and an extension
-      # Only the known extensions returned from the extensions method will be recognized as such.
-      def split(name)
-        extension = nil
-        dirname, basename = File.dirname(name), File.basename(name)
-        if basename =~ /^(.*)\.(#{extensions.keys.map {|e| Regexp.escape(e)}.join('|')})$/
-          basename = $1
-          extension = $2
-        end
-        [dirname, basename, extension]
-      end
-
-      private
-
-      def _find(dir, name, options)
-        full_filename, syntax = Sass::Util.destructure(find_real_file(dir, name, options))
-        return unless full_filename && File.readable?(full_filename)
-
-        # TODO: this preserves historical behavior, but it's possible
-        # :filename should be either normalized to the native format
-        # or consistently URI-format.
-        full_filename = full_filename.tr("\\", "/") if Sass::Util.windows?
-
-        options[:syntax] = syntax
-        options[:filename] = full_filename
-        options[:importer] = self
-        Sass::Engine.new(File.read(full_filename), options)
-      end
-    end
-  end
-end