brakeman 4.4.0 → 4.5.0

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

@@ -1,17 +0,0 @@
-module Sass::Logger; end
-
-require "sass/logger/log_level"
-require "sass/logger/base"
-require "sass/logger/delayed"
-
-module Sass
-  class << self
-    def logger=(l)
-      Thread.current[:sass_logger] = l
-    end
-
-    def logger
-      Thread.current[:sass_logger] ||= Sass::Logger::Base.new
-    end
-  end
-end

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

@@ -1,36 +0,0 @@
-require 'sass/logger/log_level'
-
-class Sass::Logger::Base
-  include Sass::Logger::LogLevel
-
-  attr_accessor :log_level
-  attr_accessor :disabled
-  attr_accessor :io
-
-  log_level :trace
-  log_level :debug
-  log_level :info
-  log_level :warn
-  log_level :error
-
-  def initialize(log_level = :debug, io = nil)
-    self.log_level = log_level
-    self.io = io
-  end
-
-  def logging_level?(level)
-    !disabled && self.class.log_level?(level, log_level)
-  end
-
-  def log(level, message)
-    _log(level, message) if logging_level?(level)
-  end
-
-  def _log(level, message)
-    if io
-      io.puts(message)
-    else
-      Kernel.warn(message)
-    end
-  end
-end

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

@@ -1,50 +0,0 @@
-require 'sass/logger/log_level'
-
-# A logger that delays messages until they're explicitly flushed to an inner
-# logger.
-#
-# This can be installed around the current logger by calling \{#install!}, and
-# the original logger can be replaced by calling \{#uninstall!}. The log
-# messages can be flushed by calling \{#flush}.
-class Sass::Logger::Delayed < Sass::Logger::Base
-  # Installs a new delayed logger as the current Sass logger, wrapping the
-  # original logger.
-  #
-  # This can be undone by calling \{#uninstall!}.
-  #
-  # @return [Sass::Logger::Delayed] The newly-created logger.
-  def self.install!
-    logger = Sass::Logger::Delayed.new(Sass.logger)
-    Sass.logger = logger
-    logger
-  end
-
-  # Creates a delayed logger wrapping `inner`.
-  #
-  # @param inner [Sass::Logger::Base] The wrapped logger.
-  def initialize(inner)
-    self.log_level = inner.log_level
-    @inner = inner
-    @messages = []
-  end
-
-  # Flushes all queued logs to the wrapped logger.
-  def flush
-    @messages.each {|(l, m)| @inner.log(l, m)}
-  end
-
-  # Uninstalls this logger from \{Sass.logger\}. This should only be called if
-  # the logger was installed using \{#install!}
-  def uninstall!
-    if Sass.logger != self
-      throw Exception.new("Can't uninstall a logger that's not currently installed.")
-    end
-
-    @inner.log_level = log_level
-    Sass.logger = @inner
-  end
-
-  def _log(level, message)
-    @messages << [level, message]
-  end
-end

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

@@ -1,45 +0,0 @@
-module Sass
-  module Logger
-    module LogLevel
-      def self.included(base)
-        base.extend(ClassMethods)
-      end
-
-      module ClassMethods
-        def inherited(subclass)
-          subclass.log_levels = subclass.superclass.log_levels.dup
-        end
-
-        attr_writer :log_levels
-
-        def log_levels
-          @log_levels ||= {}
-        end
-
-        def log_level?(level, min_level)
-          log_levels[level] >= log_levels[min_level]
-        end
-
-        def log_level(name, options = {})
-          if options[:prepend]
-            level = log_levels.values.min
-            level = level.nil? ? 0 : level - 1
-          else
-            level = log_levels.values.max
-            level = level.nil? ? 0 : level + 1
-          end
-          log_levels.update(name => level)
-          define_logger(name)
-        end
-
-        def define_logger(name, options = {})
-          class_eval <<-RUBY, __FILE__, __LINE__ + 1
-            def #{name}(message)
-              #{options.fetch(:to, :log)}(#{name.inspect}, message)
-            end
-          RUBY
-        end
-      end
-    end
-  end
-end

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

@@ -1,210 +0,0 @@
-# A namespace for the `@media` query parse tree.
-module Sass::Media
-  # A comma-separated list of queries.
-  #
-  #     media_query [ ',' S* media_query ]*
-  class QueryList
-    # The queries contained in this list.
-    #
-    # @return [Array<Query>]
-    attr_accessor :queries
-
-    # @param queries [Array<Query>] See \{#queries}
-    def initialize(queries)
-      @queries = queries
-    end
-
-    # Merges this query list with another. The returned query list
-    # queries for the intersection between the two inputs.
-    #
-    # Both query lists should be resolved.
-    #
-    # @param other [QueryList]
-    # @return [QueryList?] The merged list, or nil if there is no intersection.
-    def merge(other)
-      new_queries = queries.map {|q1| other.queries.map {|q2| q1.merge(q2)}}.flatten.compact
-      return if new_queries.empty?
-      QueryList.new(new_queries)
-    end
-
-    # Returns the CSS for the media query list.
-    #
-    # @return [String]
-    def to_css
-      queries.map {|q| q.to_css}.join(', ')
-    end
-
-    # Returns the Sass/SCSS code for the media query list.
-    #
-    # @param options [{Symbol => Object}] An options hash (see {Sass::CSS#initialize}).
-    # @return [String]
-    def to_src(options)
-      queries.map {|q| q.to_src(options)}.join(', ')
-    end
-
-    # Returns a representation of the query as an array of strings and
-    # potentially {Sass::Script::Tree::Node}s (if there's interpolation in it).
-    # When the interpolation is resolved and the strings are joined together,
-    # this will be the string representation of this query.
-    #
-    # @return [Array<String, Sass::Script::Tree::Node>]
-    def to_a
-      Sass::Util.intersperse(queries.map {|q| q.to_a}, ', ').flatten
-    end
-
-    # Returns a deep copy of this query list and all its children.
-    #
-    # @return [QueryList]
-    def deep_copy
-      QueryList.new(queries.map {|q| q.deep_copy})
-    end
-  end
-
-  # A single media query.
-  #
-  #     [ [ONLY | NOT]? S* media_type S* | expression ] [ AND S* expression ]*
-  class Query
-    # The modifier for the query.
-    #
-    # When parsed as Sass code, this contains strings and SassScript nodes. When
-    # parsed as CSS, it contains a single string (accessible via
-    # \{#resolved_modifier}).
-    #
-    # @return [Array<String, Sass::Script::Tree::Node>]
-    attr_accessor :modifier
-
-    # The type of the query (e.g. `"screen"` or `"print"`).
-    #
-    # When parsed as Sass code, this contains strings and SassScript nodes. When
-    # parsed as CSS, it contains a single string (accessible via
-    # \{#resolved_type}).
-    #
-    # @return [Array<String, Sass::Script::Tree::Node>]
-    attr_accessor :type
-
-    # The trailing expressions in the query.
-    #
-    # When parsed as Sass code, each expression contains strings and SassScript
-    # nodes. When parsed as CSS, each one contains a single string.
-    #
-    # @return [Array<Array<String, Sass::Script::Tree::Node>>]
-    attr_accessor :expressions
-
-    # @param modifier [Array<String, Sass::Script::Tree::Node>] See \{#modifier}
-    # @param type [Array<String, Sass::Script::Tree::Node>] See \{#type}
-    # @param expressions [Array<Array<String, Sass::Script::Tree::Node>>] See \{#expressions}
-    def initialize(modifier, type, expressions)
-      @modifier = modifier
-      @type = type
-      @expressions = expressions
-    end
-
-    # See \{#modifier}.
-    # @return [String]
-    def resolved_modifier
-      # modifier should contain only a single string
-      modifier.first || ''
-    end
-
-    # See \{#type}.
-    # @return [String]
-    def resolved_type
-      # type should contain only a single string
-      type.first || ''
-    end
-
-    # Merges this query with another. The returned query queries for
-    # the intersection between the two inputs.
-    #
-    # Both queries should be resolved.
-    #
-    # @param other [Query]
-    # @return [Query?] The merged query, or nil if there is no intersection.
-    def merge(other)
-      m1, t1 = resolved_modifier.downcase, resolved_type.downcase
-      m2, t2 = other.resolved_modifier.downcase, other.resolved_type.downcase
-      t1 = t2 if t1.empty?
-      t2 = t1 if t2.empty?
-      if (m1 == 'not') ^ (m2 == 'not')
-        return if t1 == t2
-        type = m1 == 'not' ? t2 : t1
-        mod = m1 == 'not' ? m2 : m1
-      elsif m1 == 'not' && m2 == 'not'
-        # CSS has no way of representing "neither screen nor print"
-        return unless t1 == t2
-        type = t1
-        mod = 'not'
-      elsif t1 != t2
-        return
-      else # t1 == t2, neither m1 nor m2 are "not"
-        type = t1
-        mod = m1.empty? ? m2 : m1
-      end
-      Query.new([mod], [type], other.expressions + expressions)
-    end
-
-    # Returns the CSS for the media query.
-    #
-    # @return [String]
-    def to_css
-      css = ''
-      css << resolved_modifier
-      css << ' ' unless resolved_modifier.empty?
-      css << resolved_type
-      css << ' and ' unless resolved_type.empty? || expressions.empty?
-      css << expressions.map do |e|
-        # It's possible for there to be script nodes in Expressions even when
-        # we're converting to CSS in the case where we parsed the document as
-        # CSS originally (as in css_test.rb).
-        e.map {|c| c.is_a?(Sass::Script::Tree::Node) ? c.to_sass : c.to_s}.join
-      end.join(' and ')
-      css
-    end
-
-    # Returns the Sass/SCSS code for the media query.
-    #
-    # @param options [{Symbol => Object}] An options hash (see {Sass::CSS#initialize}).
-    # @return [String]
-    def to_src(options)
-      src = ''
-      src << Sass::Media._interp_to_src(modifier, options)
-      src << ' ' unless modifier.empty?
-      src << Sass::Media._interp_to_src(type, options)
-      src << ' and ' unless type.empty? || expressions.empty?
-      src << expressions.map do |e|
-        Sass::Media._interp_to_src(e, options)
-      end.join(' and ')
-      src
-    end
-
-    # @see \{MediaQuery#to\_a}
-    def to_a
-      res = []
-      res += modifier
-      res << ' ' unless modifier.empty?
-      res += type
-      res << ' and ' unless type.empty? || expressions.empty?
-      res += Sass::Util.intersperse(expressions, ' and ').flatten
-      res
-    end
-
-    # Returns a deep copy of this query and all its children.
-    #
-    # @return [Query]
-    def deep_copy
-      Query.new(
-        modifier.map {|c| c.is_a?(Sass::Script::Tree::Node) ? c.deep_copy : c},
-        type.map {|c| c.is_a?(Sass::Script::Tree::Node) ? c.deep_copy : c},
-        expressions.map {|e| e.map {|c| c.is_a?(Sass::Script::Tree::Node) ? c.deep_copy : c}})
-    end
-  end
-
-  # Converts an interpolation array to source.
-  #
-  # @param interp [Array<String, Sass::Script::Tree::Node>] The interpolation array to convert.
-  # @param options [{Symbol => Object}] An options hash (see {Sass::CSS#initialize}).
-  # @return [String]
-  def self._interp_to_src(interp, options)
-    interp.map {|r| r.is_a?(String) ? r : r.to_sass(options)}.join
-  end
-end

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

@@ -1,134 +0,0 @@
-require 'fileutils'
-
-require 'sass'
-require 'sass/plugin/compiler'
-
-module Sass
-  # This module provides a single interface to the compilation of Sass/SCSS files
-  # for an application. It provides global options and checks whether CSS files
-  # need to be updated.
-  #
-  # This module is used as the primary interface with Sass
-  # when it's used as a plugin for various frameworks.
-  # All Rack-enabled frameworks are supported out of the box.
-  # The plugin is
-  # {file:SASS_REFERENCE.md#Rack_Rails_Merb_Plugin automatically activated for Rails and Merb}.
-  # Other frameworks must enable it explicitly; see {Sass::Plugin::Rack}.
-  #
-  # This module has a large set of callbacks available
-  # to allow users to run code (such as logging) when certain things happen.
-  # All callback methods are of the form `on_#{name}`,
-  # and they all take a block that's called when the given action occurs.
-  #
-  # Note that this class proxies almost all methods to its {Sass::Plugin::Compiler} instance.
-  # See \{#compiler}.
-  #
-  # @example Using a callback
-  #   Sass::Plugin.on_updating_stylesheet do |template, css|
-  #     puts "Compiling #{template} to #{css}"
-  #   end
-  #   Sass::Plugin.update_stylesheets
-  #     #=> Compiling app/sass/screen.scss to public/stylesheets/screen.css
-  #     #=> Compiling app/sass/print.scss to public/stylesheets/print.css
-  #     #=> Compiling app/sass/ie.scss to public/stylesheets/ie.css
-  # @see Sass::Plugin::Compiler
-  module Plugin
-    extend self
-
-    @checked_for_updates = false
-
-    # Whether or not Sass has **ever** checked if the stylesheets need to be updated
-    # (in this Ruby instance).
-    #
-    # @return [Boolean]
-    attr_accessor :checked_for_updates
-
-    # Same as \{#update\_stylesheets}, but respects \{#checked\_for\_updates}
-    # and the {file:SASS_REFERENCE.md#always_update-option `:always_update`}
-    # and {file:SASS_REFERENCE.md#always_check-option `:always_check`} options.
-    #
-    # @see #update_stylesheets
-    def check_for_updates
-      return unless !Sass::Plugin.checked_for_updates ||
-          Sass::Plugin.options[:always_update] || Sass::Plugin.options[:always_check]
-      update_stylesheets
-    end
-
-    # Returns the singleton compiler instance.
-    # This compiler has been pre-configured according
-    # to the plugin configuration.
-    #
-    # @return [Sass::Plugin::Compiler]
-    def compiler
-      @compiler ||= Compiler.new
-    end
-
-    # Updates out-of-date stylesheets.
-    #
-    # Checks each Sass/SCSS file in
-    # {file:SASS_REFERENCE.md#template_location-option `:template_location`}
-    # to see if it's been modified more recently than the corresponding CSS file
-    # in {file:SASS_REFERENCE.md#css_location-option `:css_location`}.
-    # If it has, it updates the CSS file.
-    #
-    # @param individual_files [Array<(String, String)>]
-    #   A list of files to check for updates
-    #   **in addition to those specified by the
-    #   {file:SASS_REFERENCE.md#template_location-option `:template_location` option}.**
-    #   The first string in each pair is the location of the Sass/SCSS file,
-    #   the second is the location of the CSS file that it should be compiled to.
-    def update_stylesheets(individual_files = [])
-      return if options[:never_update]
-      compiler.update_stylesheets(individual_files)
-    end
-
-    # Updates all stylesheets, even those that aren't out-of-date.
-    # Ignores the cache.
-    #
-    # @param individual_files [Array<(String, String)>]
-    #   A list of files to check for updates
-    #   **in addition to those specified by the
-    #   {file:SASS_REFERENCE.md#template_location-option `:template_location` option}.**
-    #   The first string in each pair is the location of the Sass/SCSS file,
-    #   the second is the location of the CSS file that it should be compiled to.
-    # @see #update_stylesheets
-    def force_update_stylesheets(individual_files = [])
-      Compiler.new(
-        options.dup.merge(
-          :never_update => false,
-          :always_update => true,
-          :cache => false)).update_stylesheets(individual_files)
-    end
-
-    # All other method invocations are proxied to the \{#compiler}.
-    #
-    # @see #compiler
-    # @see Sass::Plugin::Compiler
-    def method_missing(method, *args, &block)
-      if compiler.respond_to?(method)
-        compiler.send(method, *args, &block)
-      else
-        super
-      end
-    end
-
-    # For parity with method_missing
-    def respond_to?(method)
-      super || compiler.respond_to?(method)
-    end
-
-    # There's a small speedup by not using method missing for frequently delegated methods.
-    def options
-      compiler.options
-    end
-  end
-end
-
-if defined?(ActionController)
-  # On Rails 3+ the rails plugin is loaded at the right time in railtie.rb
-  require 'sass/plugin/rails' unless Sass::Util.ap_geq_3?
-elsif defined?(Merb::Plugins)
-  require 'sass/plugin/merb'
-else
-  require 'sass/plugin/generic'
-end