brakeman 4.4.0 → 4.5.0

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

@@ -1,134 +0,0 @@
-module Sass
-  module Plugin
-    # We keep configuration in its own self-contained file so that we can load
-    # it independently in Rails 3, where the full plugin stuff is lazy-loaded.
-    #
-    # Note that this is not guaranteed to be thread-safe. For guaranteed thread
-    # safety, use a separate {Sass::Plugin} for each thread.
-    module Configuration
-      # Returns the default options for a {Sass::Plugin::Compiler}.
-      #
-      # @return [{Symbol => Object}]
-      def default_options
-        @default_options ||= {
-          :css_location       => './public/stylesheets',
-          :always_update      => false,
-          :always_check       => true,
-          :full_exception     => true,
-          :cache_location     => ".sass-cache"
-        }.freeze
-      end
-
-      # Resets the options and
-      # {Sass::Callbacks::InstanceMethods#clear_callbacks! clears all callbacks}.
-      def reset!
-        @options = nil
-        clear_callbacks!
-      end
-
-      # An options hash.
-      # See {file:SASS_REFERENCE.md#Options the Sass options documentation}.
-      #
-      # @return [{Symbol => Object}]
-      def options
-        @options ||= default_options.dup
-      end
-
-      # Adds a new template-location/css-location mapping.
-      # This means that Sass/SCSS files in `template_location`
-      # will be compiled to CSS files in `css_location`.
-      #
-      # This is preferred over manually manipulating the
-      # {file:SASS_REFERENCE.md#template_location-option `:template_location` option}
-      # since the option can be in multiple formats.
-      #
-      # Note that this method will change `options[:template_location]`
-      # to be in the Array format.
-      # This means that even if `options[:template_location]`
-      # had previously been a Hash or a String,
-      # it will now be an Array.
-      #
-      # @param template_location [String] The location where Sass/SCSS files will be.
-      # @param css_location [String] The location where compiled CSS files will go.
-      def add_template_location(template_location, css_location = options[:css_location])
-        normalize_template_location!
-        template_location_array << [template_location, css_location]
-      end
-
-      # Removes a template-location/css-location mapping.
-      # This means that Sass/SCSS files in `template_location`
-      # will no longer be compiled to CSS files in `css_location`.
-      #
-      # This is preferred over manually manipulating the
-      # {file:SASS_REFERENCE.md#template_location-option `:template_location` option}
-      # since the option can be in multiple formats.
-      #
-      # Note that this method will change `options[:template_location]`
-      # to be in the Array format.
-      # This means that even if `options[:template_location]`
-      # had previously been a Hash or a String,
-      # it will now be an Array.
-      #
-      # @param template_location [String]
-      #   The location where Sass/SCSS files were,
-      #   which is now going to be ignored.
-      # @param css_location [String]
-      #   The location where compiled CSS files went, but will no longer go.
-      # @return [Boolean]
-      #   Non-`nil` if the given mapping already existed and was removed,
-      #   or `nil` if nothing was changed.
-      def remove_template_location(template_location, css_location = options[:css_location])
-        normalize_template_location!
-        template_location_array.delete([template_location, css_location])
-      end
-
-      # Returns the template locations configured for Sass
-      # as an array of `[template_location, css_location]` pairs.
-      # See the {file:SASS_REFERENCE.md#template_location-option `:template_location` option}
-      # for details.
-      #
-      # Modifications to the returned array may not be persistent.  Use {#add_template_location}
-      # and {#remove_template_location} instead.
-      #
-      # @return [Array<(String, String)>]
-      #   An array of `[template_location, css_location]` pairs.
-      def template_location_array
-        convert_template_location(options[:template_location], options[:css_location])
-      end
-
-      private
-
-      # Returns the given template location, as an array. If it's already an array,
-      # it is returned unmodified. Otherwise, a new array is created and returned.
-      #
-      # @param template_location [String, Array<(String, String)>]
-      #   A single template location, or a pre-normalized array of template
-      #   locations and CSS locations.
-      # @param css_location [String?]
-      #   The location for compiled CSS files.
-      # @return [Array<(String, String)>]
-      #   An array of `[template_location, css_location]` pairs.
-      def convert_template_location(template_location, css_location)
-        return template_location if template_location.is_a?(Array)
-
-        case template_location
-        when nil
-          if css_location
-            [[File.join(css_location, 'sass'), css_location]]
-          else
-            []
-          end
-        when String
-          [[template_location, css_location]]
-        else
-          template_location.to_a
-        end
-      end
-
-      def normalize_template_location!
-        options[:template_location] = convert_template_location(
-          options[:template_location], options[:css_location])
-      end
-    end
-  end
-end

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

@@ -1,15 +0,0 @@
-# The reason some options are declared here rather than in sass/plugin/configuration.rb
-# is that otherwise they'd clobber the Rails-specific options.
-# Since Rails' options are lazy-loaded in Rails 3,
-# they're reverse-merged with the default options
-# so that user configuration is preserved.
-# This means that defaults that differ from Rails'
-# must be declared here.
-
-unless defined?(Sass::GENERIC_LOADED)
-  Sass::GENERIC_LOADED = true
-
-  Sass::Plugin.options.merge!(:css_location   => './public/stylesheets',
-                              :always_update  => false,
-                              :always_check   => true)
-end

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

@@ -1,48 +0,0 @@
-unless defined?(Sass::MERB_LOADED)
-  Sass::MERB_LOADED = true
-
-  module Sass::Plugin::Configuration
-    # Different default options in a m environment.
-    def default_options
-      @default_options ||= begin
-        version = Merb::VERSION.split('.').map {|n| n.to_i}
-        if version[0] <= 0 && version[1] < 5
-          root = MERB_ROOT
-          env  = MERB_ENV
-        else
-          root = Merb.root.to_s
-          env  = Merb.environment
-        end
-
-        {
-          :always_update     => false,
-          :template_location => root + '/public/stylesheets/sass',
-          :css_location      => root + '/public/stylesheets',
-          :cache_location    => root + '/tmp/sass-cache',
-          :always_check      => env != "production",
-          :quiet             => env != "production",
-          :full_exception    => env != "production"
-        }.freeze
-      end
-    end
-  end
-
-  config = Merb::Plugins.config[:sass] || Merb::Plugins.config["sass"] || {}
-
-  if defined? config.symbolize_keys!
-    config.symbolize_keys!
-  end
-
-  Sass::Plugin.options.merge!(config)
-
-  require 'sass/plugin/rack'
-  class Sass::Plugin::MerbBootLoader < Merb::BootLoader
-    after Merb::BootLoader::RackUpApplication
-
-    def self.run
-      # Apparently there's no better way than this to add Sass
-      # to Merb's Rack stack.
-      Merb::Config[:app] = Sass::Plugin::Rack.new(Merb::Config[:app])
-    end
-  end
-end

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

@@ -1,60 +0,0 @@
-module Sass
-  module Plugin
-    # Rack middleware for compiling Sass code.
-    #
-    # ## Activate
-    #
-    #     require 'sass/plugin/rack'
-    #     use Sass::Plugin::Rack
-    #
-    # ## Customize
-    #
-    #     Sass::Plugin.options.merge!(
-    #       :cache_location => './tmp/sass-cache',
-    #       :never_update => environment != :production,
-    #       :full_exception => environment != :production)
-    #
-    # {file:SASS_REFERENCE.md#Options See the Reference for more options}.
-    #
-    # ## Use
-    #
-    # Put your Sass files in `public/stylesheets/sass`.
-    # Your CSS will be generated in `public/stylesheets`,
-    # and regenerated every request if necessary.
-    # The locations and frequency {file:SASS_REFERENCE.md#Options can be customized}.
-    # That's all there is to it!
-    class Rack
-      # The delay, in seconds, between update checks.
-      # Useful when many resources are requested for a single page.
-      # `nil` means no delay at all.
-      #
-      # @return [Float]
-      attr_accessor :dwell
-
-      # Initialize the middleware.
-      #
-      # @param app [#call] The Rack application
-      # @param dwell [Float] See \{#dwell}
-      def initialize(app, dwell = 1.0)
-        @app = app
-        @dwell = dwell
-        @check_after = Time.now.to_f
-      end
-
-      # Process a request, checking the Sass stylesheets for changes
-      # and updating them if necessary.
-      #
-      # @param env The Rack request environment
-      # @return [(#to_i, {String => String}, Object)] The Rack response
-      def call(env)
-        if @dwell.nil? || Time.now.to_f > @check_after
-          Sass::Plugin.check_for_updates
-          @check_after = Time.now.to_f + @dwell if @dwell
-        end
-        @app.call(env)
-      end
-    end
-  end
-end
-
-require 'sass/plugin'

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

@@ -1,47 +0,0 @@
-unless defined?(Sass::RAILS_LOADED)
-  Sass::RAILS_LOADED = true
-
-  module Sass::Plugin::Configuration
-    # Different default options in a rails environment.
-    def default_options
-      return @default_options if @default_options
-      opts = {
-        :quiet             => Sass::Util.rails_env != "production",
-        :full_exception    => Sass::Util.rails_env != "production",
-        :cache_location    => Sass::Util.rails_root + '/tmp/sass-cache'
-      }
-
-      opts.merge!(
-        :always_update     => false,
-        :template_location => Sass::Util.rails_root + '/public/stylesheets/sass',
-        :css_location      => Sass::Util.rails_root + '/public/stylesheets',
-        :always_check      => Sass::Util.rails_env == "development")
-
-      @default_options = opts.freeze
-    end
-  end
-
-  Sass::Plugin.options.reverse_merge!(Sass::Plugin.default_options)
-
-  # Rails 3.1 loads and handles Sass all on its own
-  if defined?(ActionController::Metal)
-    # 3.1 > Rails >= 3.0
-    require 'sass/plugin/rack'
-    Rails.configuration.middleware.use(Sass::Plugin::Rack)
-  elsif defined?(ActionController::Dispatcher) &&
-      defined?(ActionController::Dispatcher.middleware)
-    # Rails >= 2.3
-    require 'sass/plugin/rack'
-    ActionController::Dispatcher.middleware.use(Sass::Plugin::Rack)
-  else
-    module ActionController
-      class Base
-        alias_method :sass_old_process, :process
-        def process(*args)
-          Sass::Plugin.check_for_updates
-          sass_old_process(*args)
-        end
-      end
-    end
-  end
-end

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

@@ -1,199 +0,0 @@
-require 'thread'
-
-module Sass
-  module Plugin
-    # The class handles `.s[ca]ss` file staleness checks via their mtime timestamps.
-    #
-    # To speed things up two level of caches are employed:
-    #
-    # * A class-level dependency cache which stores @import paths for each file.
-    #   This is a long-lived cache that is reused by every StalenessChecker instance.
-    # * Three short-lived instance-level caches, one for file mtimes,
-    #   one for whether a file is stale during this particular run.
-    #   and one for the parse tree for a file.
-    #   These are only used by a single StalenessChecker instance.
-    #
-    # Usage:
-    #
-    # * For a one-off staleness check of a single `.s[ca]ss` file,
-    #   the class-level {stylesheet_needs_update?} method
-    #   should be used.
-    # * For a series of staleness checks (e.g. checking all files for staleness)
-    #   a StalenessChecker instance should be created,
-    #   and the instance-level \{#stylesheet\_needs\_update?} method should be used.
-    #   the caches should make the whole process significantly faster.
-    #   *WARNING*: It is important not to retain the instance for too long,
-    #   as its instance-level caches are never explicitly expired.
-    class StalenessChecker
-      @dependencies_cache = {}
-      @dependency_cache_mutex = Mutex.new
-
-      class << self
-        # TODO: attach this to a compiler instance.
-        # @private
-        attr_accessor :dependencies_cache
-        attr_reader :dependency_cache_mutex
-      end
-
-      # Creates a new StalenessChecker
-      # for checking the staleness of several stylesheets at once.
-      #
-      # @param options [{Symbol => Object}]
-      #   See {file:SASS_REFERENCE.md#Options the Sass options documentation}.
-      def initialize(options)
-        # URIs that are being actively checked for staleness. Protects against
-        # import loops.
-        @actively_checking = Set.new
-
-        # Entries in the following instance-level caches are never explicitly expired.
-        # Instead they are supposed to automatically go out of scope when a series of staleness
-        # checks (this instance of StalenessChecker was created for) is finished.
-        @mtimes, @dependencies_stale, @parse_trees = {}, {}, {}
-        @options = Sass::Engine.normalize_options(options)
-      end
-
-      # Returns whether or not a given CSS file is out of date
-      # and needs to be regenerated.
-      #
-      # @param css_file [String] The location of the CSS file to check.
-      # @param template_file [String] The location of the Sass or SCSS template
-      #   that is compiled to `css_file`.
-      # @return [Boolean] Whether the stylesheet needs to be updated.
-      def stylesheet_needs_update?(css_file, template_file, importer = nil)
-        template_file = File.expand_path(template_file)
-        begin
-          css_mtime = File.mtime(css_file)
-        rescue Errno::ENOENT
-          return true
-        end
-        stylesheet_modified_since?(template_file, css_mtime, importer)
-      end
-
-      # Returns whether a Sass or SCSS stylesheet has been modified since a given time.
-      #
-      # @param template_file [String] The location of the Sass or SCSS template.
-      # @param mtime [Time] The modification time to check against.
-      # @param importer [Sass::Importers::Base] The importer used to locate the stylesheet.
-      #   Defaults to the filesystem importer.
-      # @return [Boolean] Whether the stylesheet has been modified.
-      def stylesheet_modified_since?(template_file, mtime, importer = nil)
-        importer ||= @options[:filesystem_importer].new(".")
-        dependency_updated?(mtime).call(template_file, importer)
-      end
-
-      # Returns whether or not a given CSS file is out of date
-      # and needs to be regenerated.
-      #
-      # The distinction between this method and the instance-level \{#stylesheet\_needs\_update?}
-      # is that the instance method preserves mtime and stale-dependency caches,
-      # so it's better to use when checking multiple stylesheets at once.
-      #
-      # @param css_file [String] The location of the CSS file to check.
-      # @param template_file [String] The location of the Sass or SCSS template
-      #   that is compiled to `css_file`.
-      # @return [Boolean] Whether the stylesheet needs to be updated.
-      def self.stylesheet_needs_update?(css_file, template_file, importer = nil)
-        new(Plugin.engine_options).stylesheet_needs_update?(css_file, template_file, importer)
-      end
-
-      # Returns whether a Sass or SCSS stylesheet has been modified since a given time.
-      #
-      # The distinction between this method and the instance-level \{#stylesheet\_modified\_since?}
-      # is that the instance method preserves mtime and stale-dependency caches,
-      # so it's better to use when checking multiple stylesheets at once.
-      #
-      # @param template_file [String] The location of the Sass or SCSS template.
-      # @param mtime [Time] The modification time to check against.
-      # @param importer [Sass::Importers::Base] The importer used to locate the stylesheet.
-      #   Defaults to the filesystem importer.
-      # @return [Boolean] Whether the stylesheet has been modified.
-      def self.stylesheet_modified_since?(template_file, mtime, importer = nil)
-        new(Plugin.engine_options).stylesheet_modified_since?(template_file, mtime, importer)
-      end
-
-      private
-
-      def dependencies_stale?(uri, importer, css_mtime)
-        timestamps = @dependencies_stale[[uri, importer]] ||= {}
-        timestamps.each_pair do |checked_css_mtime, is_stale|
-          if checked_css_mtime <= css_mtime && !is_stale
-            return false
-          elsif checked_css_mtime > css_mtime && is_stale
-            return true
-          end
-        end
-        timestamps[css_mtime] = dependencies(uri, importer).any?(&dependency_updated?(css_mtime))
-      rescue Sass::SyntaxError
-        # If there's an error finding dependencies, default to recompiling.
-        true
-      end
-
-      def mtime(uri, importer)
-        @mtimes[[uri, importer]] ||=
-          begin
-            mtime = importer.mtime(uri, @options)
-            if mtime.nil?
-              with_dependency_cache {|cache| cache.delete([uri, importer])}
-              nil
-            else
-              mtime
-            end
-          end
-      end
-
-      def dependencies(uri, importer)
-        stored_mtime, dependencies =
-          with_dependency_cache {|cache| Sass::Util.destructure(cache[[uri, importer]])}
-
-        if !stored_mtime || stored_mtime < mtime(uri, importer)
-          dependencies = compute_dependencies(uri, importer)
-          with_dependency_cache do |cache|
-            cache[[uri, importer]] = [mtime(uri, importer), dependencies]
-          end
-        end
-
-        dependencies
-      end
-
-      def dependency_updated?(css_mtime)
-        proc do |uri, importer|
-          next true if @actively_checking.include?(uri)
-          begin
-            @actively_checking << uri
-            sass_mtime = mtime(uri, importer)
-            !sass_mtime ||
-              sass_mtime > css_mtime ||
-              dependencies_stale?(uri, importer, css_mtime)
-          ensure
-            @actively_checking.delete uri
-          end
-        end
-      end
-
-      def compute_dependencies(uri, importer)
-        tree(uri, importer).grep(Tree::ImportNode) do |n|
-          next if n.css_import?
-          file = n.imported_file
-          key = [file.options[:filename], file.options[:importer]]
-          @parse_trees[key] = file.to_tree
-          key
-        end.compact
-      end
-
-      def tree(uri, importer)
-        @parse_trees[[uri, importer]] ||= importer.find(uri, @options).to_tree
-      end
-
-      # Get access to the global dependency cache in a threadsafe manner.
-      # Inside the block, no other thread can access the dependency cache.
-      #
-      # @yieldparam cache [Hash] The hash that is the global dependency cache
-      # @return The value returned by the block to which this method yields
-      def with_dependency_cache
-        StalenessChecker.dependency_cache_mutex.synchronize do
-          yield StalenessChecker.dependencies_cache
-        end
-      end
-    end
-  end
-end