brakeman 4.4.0 → 4.5.0

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

@@ -1,19 +0,0 @@
-module Sass
-  module Tree
-    # A dynamic node representing returning from a function.
-    #
-    # @see Sass::Tree
-    class ReturnNode < Node
-      # The expression to return.
-      #
-      # @return [Script::Tree::Node]
-      attr_accessor :expr
-
-      # @param expr [Script::Tree::Node] The expression to return
-      def initialize(expr)
-        @expr = expr
-        super()
-      end
-    end
-  end
-end

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

@@ -1,44 +0,0 @@
-module Sass
-  module Tree
-    # A static node that is the root node of the Sass document.
-    class RootNode < Node
-      # The Sass template from which this node was created
-      #
-      # @param template [String]
-      attr_reader :template
-
-      # @param template [String] The Sass template from which this node was created
-      def initialize(template)
-        super()
-        @template = template
-      end
-
-      # Runs the dynamic Sass code and computes the CSS for the tree.
-      #
-      # @return [String] The compiled CSS.
-      def render
-        css_tree.css
-      end
-
-      # Runs the dynamic Sass code and computes the CSS for the tree, along with
-      # the sourcemap.
-      #
-      # @return [(String, Sass::Source::Map)] The compiled CSS, as well as
-      #   the source map. @see #render
-      def render_with_sourcemap
-        css_tree.css_with_sourcemap
-      end
-
-      private
-
-      def css_tree
-        Visitors::CheckNesting.visit(self)
-        result = Visitors::Perform.visit(self)
-        Visitors::CheckNesting.visit(result) # Check again to validate mixins
-        result, extends = Visitors::Cssize.visit(result)
-        Visitors::Extend.visit(result, extends)
-        result
-      end
-    end
-  end
-end

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

@@ -1,155 +0,0 @@
-require 'pathname'
-
-module Sass::Tree
-  # A static node representing a CSS rule.
-  #
-  # @see Sass::Tree
-  class RuleNode < Node
-    # The character used to include the parent selector
-    PARENT = '&'
-
-    # The CSS selector for this rule,
-    # interspersed with {Sass::Script::Tree::Node}s
-    # representing `#{}`-interpolation.
-    # Any adjacent strings will be merged together.
-    #
-    # @return [Array<String, Sass::Script::Tree::Node>]
-    attr_accessor :rule
-
-    # The CSS selector for this rule, without any unresolved
-    # interpolation but with parent references still intact. It's only
-    # guaranteed to be set once {Tree::Visitors::Perform} has been
-    # run, but it may be set before then for optimization reasons.
-    #
-    # @return [Selector::CommaSequence]
-    attr_accessor :parsed_rules
-
-    # The CSS selector for this rule, without any unresolved
-    # interpolation or parent references. It's only set once
-    # {Tree::Visitors::Perform} has been run.
-    #
-    # @return [Selector::CommaSequence]
-    attr_accessor :resolved_rules
-
-    # How deep this rule is indented
-    # relative to a base-level rule.
-    # This is only greater than 0 in the case that:
-    #
-    # * This node is in a CSS tree
-    # * The style is :nested
-    # * This is a child rule of another rule
-    # * The parent rule has properties, and thus will be rendered
-    #
-    # @return [Integer]
-    attr_accessor :tabs
-
-    # The entire selector source range for this rule.
-    # @return [Sass::Source::Range]
-    attr_accessor :selector_source_range
-
-    # Whether or not this rule is the last rule in a nested group.
-    # This is only set in a CSS tree.
-    #
-    # @return [Boolean]
-    attr_accessor :group_end
-
-    # The stack trace.
-    # This is only readable in a CSS tree as it is written during the perform step
-    # and only when the :trace_selectors option is set.
-    #
-    # @return [String]
-    attr_accessor :stack_trace
-
-    # @param rule [Array<String, Sass::Script::Tree::Node>, Sass::Selector::CommaSequence]
-    #   The CSS rule, either unparsed or parsed.
-    # @param selector_source_range [Sass::Source::Range]
-    def initialize(rule, selector_source_range = nil)
-      if rule.is_a?(Sass::Selector::CommaSequence)
-        @rule = [rule.to_s]
-        @parsed_rules = rule
-      else
-        merged = Sass::Util.merge_adjacent_strings(rule)
-        @rule = Sass::Util.strip_string_array(merged)
-        try_to_parse_non_interpolated_rules
-      end
-      @selector_source_range = selector_source_range
-      @tabs = 0
-      super()
-    end
-
-    # If we've precached the parsed selector, set the line on it, too.
-    def line=(line)
-      @parsed_rules.line = line if @parsed_rules
-      super
-    end
-
-    # If we've precached the parsed selector, set the filename on it, too.
-    def filename=(filename)
-      @parsed_rules.filename = filename if @parsed_rules
-      super
-    end
-
-    # Compares the contents of two rules.
-    #
-    # @param other [Object] The object to compare with
-    # @return [Boolean] Whether or not this node and the other object
-    #   are the same
-    def ==(other)
-      self.class == other.class && rule == other.rule && super
-    end
-
-    # Adds another {RuleNode}'s rules to this one's.
-    #
-    # @param node [RuleNode] The other node
-    def add_rules(node)
-      @rule = Sass::Util.strip_string_array(
-        Sass::Util.merge_adjacent_strings(@rule + ["\n"] + node.rule))
-      try_to_parse_non_interpolated_rules
-    end
-
-    # @return [Boolean] Whether or not this rule is continued on the next line
-    def continued?
-      last = @rule.last
-      last.is_a?(String) && last[-1] == ?,
-    end
-
-    # A hash that will be associated with this rule in the CSS document
-    # if the {file:SASS_REFERENCE.md#debug_info-option `:debug_info` option} is enabled.
-    # This data is used by e.g. [the FireSass Firebug
-    # extension](https://addons.mozilla.org/en-US/firefox/addon/103988).
-    #
-    # @return [{#to_s => #to_s}]
-    def debug_info
-      {:filename => filename && ("file://" + Sass::Util.escape_uri(File.expand_path(filename))),
-       :line => line}
-    end
-
-    # A rule node is invisible if it has only placeholder selectors.
-    def invisible?
-      resolved_rules.members.all? {|seq| seq.has_placeholder?}
-    end
-
-    private
-
-    def try_to_parse_non_interpolated_rules
-      @parsed_rules = nil
-      return unless @rule.all? {|t| t.is_a?(String)}
-
-      # We don't use real filename/line info because we don't have it yet.
-      # When we get it, we'll set it on the parsed rules if possible.
-      parser = nil
-      warnings = Sass::Util.silence_warnings do
-        parser = Sass::SCSS::StaticParser.new(@rule.join.strip, nil, nil, 1)
-        # rubocop:disable RescueModifier
-        @parsed_rules = parser.parse_selector rescue nil
-        # rubocop:enable RescueModifier
-
-        $stderr.string
-      end
-
-      # If parsing produces a warning, throw away the result so we can parse
-      # later with the real filename info.
-      @parsed_rules = nil unless warnings.empty?
-    end
-  end
-end

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

@@ -1,38 +0,0 @@
-module Sass::Tree
-  # A static node representing a `@supports` rule.
-  #
-  # @see Sass::Tree
-  class SupportsNode < DirectiveNode
-    # The name, which may include a browser prefix.
-    #
-    # @return [String]
-    attr_accessor :name
-
-    # The supports condition.
-    #
-    # @return [Sass::Supports::Condition]
-    attr_accessor :condition
-
-    # @param condition [Sass::Supports::Condition] See \{#condition}
-    def initialize(name, condition)
-      @name = name
-      @condition = condition
-      super('')
-    end
-
-    # @see DirectiveNode#value
-    def value; raise NotImplementedError; end
-
-    # @see DirectiveNode#resolved_value
-    def resolved_value
-      @resolved_value ||= "@#{name} #{condition.to_css}"
-    end
-
-    # True when the directive has no visible children.
-    #
-    # @return [Boolean]
-    def invisible?
-      children.all? {|c| c.invisible?}
-    end
-  end
-end

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

@@ -1,33 +0,0 @@
-require 'sass/tree/node'
-
-module Sass::Tree
-  # A solely static node left over after a mixin include or @content has been performed.
-  # Its sole purpose is to wrap exceptions to add to the backtrace.
-  #
-  # @see Sass::Tree
-  class TraceNode < Node
-    # The name of the trace entry to add.
-    #
-    # @return [String]
-    attr_reader :name
-
-    # @param name [String] The name of the trace entry to add.
-    def initialize(name)
-      @name = name
-      self.has_children = true
-      super()
-    end
-
-    # Initializes this node from an existing node.
-    # @param name [String] The name of the trace entry to add.
-    # @param node [Node] The node to copy information from.
-    # @return [TraceNode]
-    def self.from_node(name, node)
-      trace = new(name)
-      trace.line = node.line
-      trace.filename = node.filename
-      trace.options = node.options
-      trace
-    end
-  end
-end

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

@@ -1,36 +0,0 @@
-module Sass
-  module Tree
-    # A dynamic node representing a variable definition.
-    #
-    # @see Sass::Tree
-    class VariableNode < Node
-      # The name of the variable.
-      # @return [String]
-      attr_reader :name
-
-      # The parse tree for the variable value.
-      # @return [Script::Tree::Node]
-      attr_accessor :expr
-
-      # Whether this is a guarded variable assignment (`!default`).
-      # @return [Boolean]
-      attr_reader :guarded
-
-      # Whether this is a global variable assignment (`!global`).
-      # @return [Boolean]
-      attr_reader :global
-
-      # @param name [String] The name of the variable
-      # @param expr [Script::Tree::Node] See \{#expr}
-      # @param guarded [Boolean] See \{#guarded}
-      # @param global [Boolean] See \{#global}
-      def initialize(name, expr, guarded, global)
-        @name = name
-        @expr = expr
-        @guarded = guarded
-        @global = global
-        super()
-      end
-    end
-  end
-end

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

@@ -1,72 +0,0 @@
-# Visitors are used to traverse the Sass parse tree.
-# Visitors should extend {Visitors::Base},
-# which provides a small amount of scaffolding for traversal.
-module Sass::Tree::Visitors
-  # The abstract base class for Sass visitors.
-  # Visitors should extend this class,
-  # then implement `visit_*` methods for each node they care about
-  # (e.g. `visit_rule` for {RuleNode} or `visit_for` for {ForNode}).
-  # These methods take the node in question as argument.
-  # They may `yield` to visit the child nodes of the current node.
-  #
-  # *Note*: due to the unusual nature of {Sass::Tree::IfNode},
-  # special care must be taken to ensure that it is properly handled.
-  # In particular, there is no built-in scaffolding
-  # for dealing with the return value of `@else` nodes.
-  #
-  # @abstract
-  class Base
-    # Runs the visitor on a tree.
-    #
-    # @param root [Tree::Node] The root node of the Sass tree.
-    # @return [Object] The return value of \{#visit} for the root node.
-    def self.visit(root)
-      new.send(:visit, root)
-    end
-
-    protected
-
-    # Runs the visitor on the given node.
-    # This can be overridden by subclasses that need to do something for each node.
-    #
-    # @param node [Tree::Node] The node to visit.
-    # @return [Object] The return value of the `visit_*` method for this node.
-    def visit(node)
-      if respond_to?(node.class.visit_method, true)
-        send(node.class.visit_method, node) {visit_children(node)}
-      else
-        visit_children(node)
-      end
-    end
-
-    # Visit the child nodes for a given node.
-    # This can be overridden by subclasses that need to do something
-    # with the child nodes' return values.
-    #
-    # This method is run when `visit_*` methods `yield`,
-    # and its return value is returned from the `yield`.
-    #
-    # @param parent [Tree::Node] The parent node of the children to visit.
-    # @return [Array<Object>] The return values of the `visit_*` methods for the children.
-    def visit_children(parent)
-      parent.children.map {|c| visit(c)}
-    end
-
-    # Returns the name of a node as used in the `visit_*` method.
-    #
-    # @param [Tree::Node] node The node.
-    # @return [String] The name.
-    def self.node_name(node)
-      Sass::Util.deprecated(self, "Call node.class.node_name instead.")
-      node.class.node_name
-    end
-
-    # `yield`s, then runs the visitor on the `@else` clause if the node has one.
-    # This exists to ensure that the contents of the `@else` clause get visited.
-    def visit_if(node)
-      yield
-      visit(node.else) if node.else
-      node
-    end
-  end
-end

data/bundle/ruby/2.5.0/gems/sass-3.4.25/lib/sass/tree/visitors/check_nesting.rb

@@ -1,173 +0,0 @@
-# A visitor for checking that all nodes are properly nested.
-class Sass::Tree::Visitors::CheckNesting < Sass::Tree::Visitors::Base
-  protected
-
-  def initialize
-    @parents = []
-    @parent = nil
-    @current_mixin_def = nil
-  end
-
-  def visit(node)
-    if (error = @parent && (
-        try_send(@parent.class.invalid_child_method_name, @parent, node) ||
-        try_send(node.class.invalid_parent_method_name, @parent, node)))
-      raise Sass::SyntaxError.new(error)
-    end
-    super
-  rescue Sass::SyntaxError => e
-    e.modify_backtrace(:filename => node.filename, :line => node.line)
-    raise e
-  end
-
-  CONTROL_NODES = [Sass::Tree::EachNode, Sass::Tree::ForNode, Sass::Tree::IfNode,
-                   Sass::Tree::WhileNode, Sass::Tree::TraceNode]
-  SCRIPT_NODES = [Sass::Tree::ImportNode] + CONTROL_NODES
-  def visit_children(parent)
-    old_parent = @parent
-
-    # When checking a static tree, resolve at-roots to be sure they won't send
-    # nodes where they don't belong.
-    if parent.is_a?(Sass::Tree::AtRootNode) && parent.resolved_value
-      old_parents = @parents
-      @parents = @parents.reject {|p| parent.exclude_node?(p)}
-      @parent = Sass::Util.enum_with_index(@parents.reverse).
-        find {|p, i| !transparent_parent?(p, @parents[-i - 2])}.first
-
-      begin
-        return super
-      ensure
-        @parents = old_parents
-        @parent = old_parent
-      end
-    end
-
-    unless transparent_parent?(parent, old_parent)
-      @parent = parent
-    end
-
-    @parents.push parent
-    begin
-      super
-    ensure
-      @parent = old_parent
-      @parents.pop
-    end
-  end
-
-  def visit_root(node)
-    yield
-  rescue Sass::SyntaxError => e
-    e.sass_template ||= node.template
-    raise e
-  end
-
-  def visit_import(node)
-    yield
-  rescue Sass::SyntaxError => e
-    e.modify_backtrace(:filename => node.children.first.filename)
-    e.add_backtrace(:filename => node.filename, :line => node.line)
-    raise e
-  end
-
-  def visit_mixindef(node)
-    @current_mixin_def, old_mixin_def = node, @current_mixin_def
-    yield
-  ensure
-    @current_mixin_def = old_mixin_def
-  end
-
-  def invalid_content_parent?(parent, child)
-    if @current_mixin_def
-      @current_mixin_def.has_content = true
-      nil
-    else
-      "@content may only be used within a mixin."
-    end
-  end
-
-  def invalid_charset_parent?(parent, child)
-    "@charset may only be used at the root of a document." unless parent.is_a?(Sass::Tree::RootNode)
-  end
-
-  VALID_EXTEND_PARENTS = [Sass::Tree::RuleNode, Sass::Tree::MixinDefNode, Sass::Tree::MixinNode]
-  def invalid_extend_parent?(parent, child)
-    return if is_any_of?(parent, VALID_EXTEND_PARENTS)
-    "Extend directives may only be used within rules."
-  end
-
-  INVALID_IMPORT_PARENTS = CONTROL_NODES +
-    [Sass::Tree::MixinDefNode, Sass::Tree::MixinNode]
-  def invalid_import_parent?(parent, child)
-    unless (@parents.map {|p| p.class} & INVALID_IMPORT_PARENTS).empty?
-      return "Import directives may not be used within control directives or mixins."
-    end
-    return if parent.is_a?(Sass::Tree::RootNode)
-    return "CSS import directives may only be used at the root of a document." if child.css_import?
-  rescue Sass::SyntaxError => e
-    e.modify_backtrace(:filename => child.imported_file.options[:filename])
-    e.add_backtrace(:filename => child.filename, :line => child.line)
-    raise e
-  end
-
-  def invalid_mixindef_parent?(parent, child)
-    return if (@parents.map {|p| p.class} & INVALID_IMPORT_PARENTS).empty?
-    "Mixins may not be defined within control directives or other mixins."
-  end
-
-  def invalid_function_parent?(parent, child)
-    return if (@parents.map {|p| p.class} & INVALID_IMPORT_PARENTS).empty?
-    "Functions may not be defined within control directives or other mixins."
-  end
-
-  VALID_FUNCTION_CHILDREN = [
-    Sass::Tree::CommentNode,  Sass::Tree::DebugNode, Sass::Tree::ReturnNode,
-    Sass::Tree::VariableNode, Sass::Tree::WarnNode, Sass::Tree::ErrorNode
-  ] + CONTROL_NODES
-  def invalid_function_child?(parent, child)
-    return if is_any_of?(child, VALID_FUNCTION_CHILDREN)
-    "Functions can only contain variable declarations and control directives."
-  end
-
-  VALID_PROP_CHILDREN = CONTROL_NODES + [Sass::Tree::CommentNode,
-                                         Sass::Tree::PropNode,
-                                         Sass::Tree::MixinNode]
-  def invalid_prop_child?(parent, child)
-    return if is_any_of?(child, VALID_PROP_CHILDREN)
-    "Illegal nesting: Only properties may be nested beneath properties."
-  end
-
-  VALID_PROP_PARENTS = [Sass::Tree::RuleNode, Sass::Tree::KeyframeRuleNode, Sass::Tree::PropNode,
-                        Sass::Tree::MixinDefNode, Sass::Tree::DirectiveNode, Sass::Tree::MixinNode]
-  def invalid_prop_parent?(parent, child)
-    return if is_any_of?(parent, VALID_PROP_PARENTS)
-    "Properties are only allowed within rules, directives, mixin includes, or other properties." +
-      child.pseudo_class_selector_message
-  end
-
-  def invalid_return_parent?(parent, child)
-    "@return may only be used within a function." unless parent.is_a?(Sass::Tree::FunctionNode)
-  end
-
-  private
-
-  # Whether `parent` should be assigned to `@parent`.
-  def transparent_parent?(parent, grandparent)
-    is_any_of?(parent, SCRIPT_NODES) ||
-      (parent.bubbles? &&
-       !grandparent.is_a?(Sass::Tree::RootNode) &&
-       !grandparent.is_a?(Sass::Tree::AtRootNode))
-  end
-
-  def is_any_of?(val, classes)
-    classes.each do |c|
-      return true if val.is_a?(c)
-    end
-    false
-  end
-
-  def try_send(method, *args)
-    return unless respond_to?(method, true)
-    send(method, *args)
-  end
-end