sass 3.3.0 → 3.4.25

data/lib/sass/script/tree/interpolation.rb

@@ -23,6 +23,21 @@ module Sass::Script::Tree
     #   SassScript.
     attr_reader :originally_text
 
+    # @return [Boolean] Whether a color value passed to the interpolation should
+    #   generate a warning.
+    attr_reader :warn_for_color
+
+    # The type of interpolation deprecation for this node.
+    #
+    # This can be `:none`, indicating that the node doesn't use deprecated
+    # interpolation; `:immediate`, indicating that a deprecation warning should
+    # be emitted as soon as possible; or `:potential`, indicating that a
+    # deprecation warning should be emitted if the resulting string is used in a
+    # way that would distinguish it from a list.
+    #
+    # @return [Symbol]
+    attr_reader :deprecation
+
     # Interpolation in a property is of the form `before #{mid} after`.
     #
     # @param before [Node] See {Interpolation#before}
@@ -31,16 +46,19 @@ module Sass::Script::Tree
     # @param wb [Boolean] See {Interpolation#whitespace_before}
     # @param wa [Boolean] See {Interpolation#whitespace_after}
     # @param originally_text [Boolean] See {Interpolation#originally_text}
+    # @param warn_for_color [Boolean] See {Interpolation#warn_for_color}
     # @comment
     #   rubocop:disable ParameterLists
-    def initialize(before, mid, after, wb, wa, originally_text = false)
+    def initialize(before, mid, after, wb, wa, opts = {})
       # rubocop:enable ParameterLists
       @before = before
       @mid = mid
       @after = after
       @whitespace_before = wb
       @whitespace_after = wa
-      @originally_text = originally_text
+      @originally_text = opts[:originally_text] || false
+      @warn_for_color = opts[:warn_for_color] || false
+      @deprecation = opts[:deprecation] || :none
     end
 
     # @return [String] A human-readable s-expression representation of the interpolation
@@ -50,6 +68,8 @@ module Sass::Script::Tree
 
     # @see Node#to_sass
     def to_sass(opts = {})
+      return to_quoted_equivalent.to_sass if deprecation == :immediate
+
       res = ""
       res << @before.to_sass(opts) if @before
       res << ' ' if @before && @whitespace_before
@@ -61,6 +81,19 @@ module Sass::Script::Tree
       res
     end
 
+    # Returns an `unquote()` expression that will evaluate to the same value as
+    # this interpolation.
+    #
+    # @return [Sass::Script::Tree::Node]
+    def to_quoted_equivalent
+      Funcall.new(
+        "unquote",
+        [to_string_interpolation(self)],
+        Sass::Util::NormalizedMap.new,
+        nil,
+        nil)
+    end
+
     # Returns the three components of the interpolation, `before`, `mid`, and `after`.
     #
     # @return [Array<Node>]
@@ -81,6 +114,49 @@ module Sass::Script::Tree
 
     protected
 
+    # Converts a script node into a corresponding string interpolation
+    # expression.
+    #
+    # @param node_or_interp [Sass::Script::Tree::Node]
+    # @return [Sass::Script::Tree::StringInterpolation]
+    def to_string_interpolation(node_or_interp)
+      unless node_or_interp.is_a?(Interpolation)
+        node = node_or_interp
+        return string_literal(node.value.to_s) if node.is_a?(Literal)
+        if node.is_a?(StringInterpolation)
+          return concat(string_literal(node.quote), concat(node, string_literal(node.quote)))
+        end
+        return StringInterpolation.new(string_literal(""), node, string_literal(""))
+      end
+
+      interp = node_or_interp
+      after_string_or_interp =
+        if interp.after
+          to_string_interpolation(interp.after)
+        else
+          string_literal("")
+        end
+      if interp.after && interp.whitespace_after
+        after_string_or_interp = concat(string_literal(' '), after_string_or_interp)
+      end
+
+      mid_string_or_interp = to_string_interpolation(interp.mid)
+
+      before_string_or_interp =
+        if interp.before
+          to_string_interpolation(interp.before)
+        else
+          string_literal("")
+        end
+      if interp.before && interp.whitespace_before
+        before_string_or_interp = concat(before_string_or_interp, string_literal(' '))
+      end
+
+      concat(before_string_or_interp, concat(mid_string_or_interp, after_string_or_interp))
+    end
+
+    private
+
     # Evaluates the interpolation.
     #
     # @param environment [Sass::Environment] The environment in which to evaluate the SassScript
@@ -90,11 +166,58 @@ module Sass::Script::Tree
       res = ""
       res << @before.perform(environment).to_s if @before
       res << " " if @before && @whitespace_before
+
       val = @mid.perform(environment)
-      res << (val.is_a?(Sass::Script::Value::String) ? val.value : val.to_s)
+      if @warn_for_color && val.is_a?(Sass::Script::Value::Color) && val.name
+        alternative = Operation.new(Sass::Script::Value::String.new("", :string), @mid, :plus)
+        Sass::Util.sass_warn <<MESSAGE
+WARNING on line #{line}, column #{source_range.start_pos.offset}#{" of #{filename}" if filename}:
+You probably don't mean to use the color value `#{val}' in interpolation here.
+It may end up represented as #{val.inspect}, which will likely produce invalid CSS.
+Always quote color names when using them as strings (for example, "#{val}").
+If you really want to use the color value here, use `#{alternative.to_sass}'.
+MESSAGE
+      end
+
+      res << val.to_s(:quote => :none)
       res << " " if @after && @whitespace_after
       res << @after.perform(environment).to_s if @after
-      opts(Sass::Script::Value::String.new(res))
+      str = Sass::Script::Value::String.new(
+        res, :identifier,
+        (to_quoted_equivalent.to_sass if deprecation == :potential))
+      str.source_range = source_range
+      opts(str)
+    end
+
+    # Concatenates two string literals or string interpolation expressions.
+    #
+    # @param string_or_interp1 [Sass::Script::Tree::Literal|Sass::Script::Tree::StringInterpolation]
+    # @param string_or_interp2 [Sass::Script::Tree::Literal|Sass::Script::Tree::StringInterpolation]
+    # @return [Sass::Script::Tree::StringInterpolation]
+    def concat(string_or_interp1, string_or_interp2)
+      if string_or_interp1.is_a?(Literal) && string_or_interp2.is_a?(Literal)
+        return string_literal(string_or_interp1.value.value + string_or_interp2.value.value)
+      end
+
+      if string_or_interp1.is_a?(Literal)
+        string = string_or_interp1
+        interp = string_or_interp2
+        before = string_literal(string.value.value + interp.before.value.value)
+        return StringInterpolation.new(before, interp.mid, interp.after)
+      end
+
+      StringInterpolation.new(
+        string_or_interp1.before,
+        string_or_interp1.mid,
+        concat(string_or_interp1.after, string_or_interp2))
+    end
+
+    # Returns a string literal with the given contents.
+    #
+    # @param string [String]
+    # @return string [Sass::Script::Tree::Literal]
+    def string_literal(string)
+      Literal.new(Sass::Script::Value::String.new(string, :string))
     end
   end
 end

data/lib/sass/script/tree/list_literal.rb

@@ -28,11 +28,8 @@ module Sass::Script::Tree
     # @see Value#to_sass
     def to_sass(opts = {})
       return "()" if elements.empty?
-      precedence = Sass::Script::Parser.precedence_of(separator)
       members = elements.map do |v|
-        if v.is_a?(ListLiteral) && Sass::Script::Parser.precedence_of(v.separator) <= precedence ||
-            separator == :space && v.is_a?(UnaryOperation) &&
-            (v.operator == :minus || v.operator == :plus)
+        if element_needs_parens?(v)
           "(#{v.to_sass(opts)})"
         else
           v.to_sass(opts)
@@ -55,6 +52,10 @@ module Sass::Script::Tree
       "(#{elements.map {|e| e.inspect}.join(separator == :space ? ' ' : ', ')})"
     end
 
+    def force_division!
+      # Do nothing. Lists prevent division propagation.
+    end
+
     protected
 
     def _perform(environment)
@@ -68,6 +69,32 @@ module Sass::Script::Tree
 
     private
 
+    # Returns whether an element in the list should be wrapped in parentheses
+    # when serialized to Sass.
+    def element_needs_parens?(element)
+      if element.is_a?(ListLiteral)
+        return Sass::Script::Parser.precedence_of(element.separator) <=
+               Sass::Script::Parser.precedence_of(separator)
+      end
+
+      return false unless separator == :space
+
+      if element.is_a?(UnaryOperation)
+        return element.operator == :minus || element.operator == :plus
+      end
+
+      return false unless element.is_a?(Operation)
+      return true unless element.operator == :div
+      !(is_literal_number?(element.operand1) && is_literal_number?(element.operand2))
+    end
+
+    # Returns whether a value is a number literal that shouldn't be divided.
+    def is_literal_number?(value)
+      value.is_a?(Literal) &&
+        value.value.is_a?((Sass::Script::Value::Number)) &&
+        !value.value.original.nil?
+    end
+
     def sep_str(opts = options)
       return ' ' if separator == :space
       return ',' if opts && opts[:style] == :compressed

data/lib/sass/script/tree/literal.rb

@@ -35,6 +35,10 @@ module Sass::Script::Tree
       value.inspect
     end
 
+    def force_division!
+      value.original = nil if value.is_a?(Sass::Script::Value::Number)
+    end
+
     protected
 
     def _perform(environment)

data/lib/sass/script/tree/node.rb

@@ -10,7 +10,7 @@ module Sass::Script::Tree
 
     # The line of the document on which this node appeared.
     #
-    # @return [Fixnum]
+    # @return [Integer]
     attr_accessor :line
 
     # The source range in the document on which this node appeared.
@@ -23,9 +23,17 @@ module Sass::Script::Tree
     # @return [String]
     attr_accessor :filename
 
+    # The warning that this node should emit if it executes in a way that's not
+    # safe for a CSS variable value.
+    #
+    # This is `nil` if this is not in a CSS variable value.
+    #
+    # @return [Sass::Script::CssVariableWarning]
+    attr_accessor :css_variable_warning
+
     # Sets the options hash for this node,
     # as well as for all child nodes.
-    # See {file:SASS_REFERENCE.md#sass_options the Sass options documentation}.
+    # See {file:SASS_REFERENCE.md#Options the Sass options documentation}.
     #
     # @param options [{Symbol => Object}] The options
     def options=(options)
@@ -62,6 +70,10 @@ module Sass::Script::Tree
 
     # Returns the text of this SassScript expression.
     #
+    # @options opts :quote [String]
+    #   The preferred quote style for quoted strings. If `:none`, strings are
+    #   always emitted unquoted.
+    #
     # @return [String]
     def to_sass(opts = {})
       Sass::Util.abstract(self)
@@ -75,12 +87,18 @@ module Sass::Script::Tree
       Sass::Util.abstract(self)
     end
 
+    # Forces any division operations with number literals in this expression to
+    # do real division, rather than returning strings.
+    def force_division!
+      children.each {|c| c.force_division!}
+    end
+
     protected
 
     # Converts underscores to dashes if the :dasherize option is set.
     def dasherize(s, opts)
       if opts[:dasherize]
-        s.gsub(/_/, '-')
+        s.tr('_', '-')
       else
         s
       end

data/lib/sass/script/tree/operation.rb

@@ -2,6 +2,9 @@ module Sass::Script::Tree
   # A SassScript parse node representing a binary operation,
   # such as `$a + $b` or `"foo" + 1`.
   class Operation < Node
+    @@color_arithmetic_deprecation = Sass::Deprecation.new
+    @@unitless_equals_deprecation = Sass::Deprecation.new
+
     attr_reader :operand1
     attr_reader :operand2
     attr_reader :operator
@@ -78,16 +81,66 @@ module Sass::Script::Tree
           "Invalid null operation: \"#{value1.inspect} #{@operator} #{value2.inspect}\".")
       end
 
+      if css_variable_warning && @operator == :div &&
+         !(value1.is_a?(Sass::Script::Value::Number) && value1.original &&
+           value2.is_a?(Sass::Script::Value::Number) && value2.original) &&
+         !(value1.is_a?(Sass::Script::Value::String) && value2.is_a?(Sass::Script::Value::String))
+        css_variable_warning.warn!
+      end
+
       begin
-        opts(value1.send(@operator, value2))
+        result = opts(value1.send(@operator, value2))
       rescue NoMethodError => e
         raise e unless e.name.to_s == @operator.to_s
         raise Sass::SyntaxError.new("Undefined operation: \"#{value1} #{@operator} #{value2}\".")
       end
+
+      warn_for_color_arithmetic(value1, value2)
+      warn_for_unitless_equals(value1, value2, result)
+
+      result
     end
 
     private
 
+    def warn_for_color_arithmetic(value1, value2)
+      return unless @operator == :plus || @operator == :times || @operator == :minus ||
+                    @operator == :div || @operator == :mod
+
+      if value1.is_a?(Sass::Script::Value::Number)
+        return unless value2.is_a?(Sass::Script::Value::Color)
+      elsif value1.is_a?(Sass::Script::Value::Color)
+        return unless value2.is_a?(Sass::Script::Value::Color) || value2.is_a?(Sass::Script::Value::Number)
+      else
+        return
+      end
+
+      @@color_arithmetic_deprecation.warn(filename, line, <<WARNING)
+The operation `#{value1} #{@operator} #{value2}` is deprecated and will be an error in future versions.
+Consider using Sass's color functions instead.
+http://sass-lang.com/documentation/Sass/Script/Functions.html#other_color_functions
+WARNING
+    end
+
+    def warn_for_unitless_equals(value1, value2, result)
+      return unless @operator == :eq || @operator == :neq
+      return unless value1.is_a?(Sass::Script::Value::Number)
+      return unless value2.is_a?(Sass::Script::Value::Number)
+      return unless value1.unitless? != value2.unitless?
+      return unless result == (if @operator == :eq
+                                 Sass::Script::Value::Bool::TRUE
+                               else
+                                 Sass::Script::Value::Bool::FALSE
+                               end)
+
+      operation = "#{value1.to_sass} #{@operator == :eq ? '==' : '!='} #{value2.to_sass}"
+      future_value = @operator == :neq
+      @@unitless_equals_deprecation.warn(filename, line, <<WARNING)
+The result of `#{operation}` will be `#{future_value}` in future releases of Sass.
+Unitless numbers will no longer be equal to the same numbers with units.
+WARNING
+    end
+
     def operand_to_sass(op, side, opts)
       return "(#{op.to_sass(opts)})" if op.is_a?(Sass::Script::Tree::ListLiteral)
       return op.to_sass(opts) unless op.is_a?(Operation)

data/lib/sass/script/tree/selector.rb

@@ -0,0 +1,26 @@
+module Sass::Script::Tree
+  # A SassScript node that will resolve to the current selector.
+  class Selector < Node
+    def initialize; end
+
+    def children
+      []
+    end
+
+    def to_sass(opts = {})
+      '&'
+    end
+
+    def deep_copy
+      dup
+    end
+
+    protected
+
+    def _perform(environment)
+      selector = environment.selector
+      return opts(Sass::Script::Value::Null.new) unless selector
+      opts(selector.to_sass_script)
+    end
+  end
+end

data/lib/sass/script/tree/string_interpolation.rb

@@ -3,12 +3,39 @@ module Sass::Script::Tree
   #
   # @see Interpolation
   class StringInterpolation < Node
+    # @return [Literal] The string literal before this interpolation.
+    attr_reader :before
+
+    # @return [Node] The SassScript within the interpolation
+    attr_reader :mid
+
+    # @return [StringInterpolation, Literal]
+    #     The string literal or string interpolation before this interpolation.
+    attr_reader :after
+
+    # Whether this is a CSS string or a CSS identifier. The difference is that
+    # strings are written with double-quotes, while identifiers aren't.
+    #
+    # String interpolations are only ever identifiers if they're quote-like
+    # functions such as `url()`.
+    #
+    # @return [Symbol] `:string` or `:identifier`
+    def type
+      @before.value.type
+    end
+
+    # Returns the quote character that should be used to wrap a Sass
+    # representation of this interpolation.
+    def quote
+      quote_for(self) || '"'
+    end
+
     # Interpolation in a string is of the form `"before #{mid} after"`,
     # where `before` and `after` may include more interpolation.
     #
-    # @param before [Node] The string before the interpolation
-    # @param mid [Node] The SassScript within the interpolation
-    # @param after [Node] The string after the interpolation
+    # @param before [StringInterpolation, Literal] See {StringInterpolation#before}
+    # @param mid [Node] See {StringInterpolation#mid}
+    # @param after [Literal] See {StringInterpolation#after}
     def initialize(before, mid, after)
       @before = before
       @mid = mid
@@ -22,32 +49,15 @@ module Sass::Script::Tree
 
     # @see Node#to_sass
     def to_sass(opts = {})
-      # We can get rid of all of this when we remove the deprecated :equals context
-      # XXX CE: It's gone now but I'm not sure what can be removed now.
-      before_unquote, before_quote_char, before_str = parse_str(@before.to_sass(opts))
-      after_unquote, after_quote_char, after_str = parse_str(@after.to_sass(opts))
-      unquote = before_unquote || after_unquote ||
-        (before_quote_char && !after_quote_char && !after_str.empty?) ||
-        (!before_quote_char && after_quote_char && !before_str.empty?)
-      quote_char =
-        if before_quote_char && after_quote_char && before_quote_char != after_quote_char
-          before_str.gsub!("\\'", "'")
-          before_str.gsub!('"', "\\\"")
-          after_str.gsub!("\\'", "'")
-          after_str.gsub!('"', "\\\"")
-          '"'
-        else
-          before_quote_char || after_quote_char
-        end
+      quote = type == :string ? opts[:quote] || quote_for(self) || '"' : :none
+      opts = opts.merge(:quote => quote)
 
       res = ""
-      res << 'unquote(' if unquote
-      res << quote_char if quote_char
-      res << before_str
-      res << '#{' << @mid.to_sass(opts) << '}'
-      res << after_str
-      res << quote_char if quote_char
-      res << ')' if unquote
+      res << quote if quote != :none
+      res << _to_sass(before, opts)
+      res << '#{' << @mid.to_sass(opts.merge(:quote => nil)) << '}'
+      res << _to_sass(after, opts)
+      res << quote if quote != :none
       res
     end
 
@@ -81,24 +91,35 @@ module Sass::Script::Tree
       before = @before.perform(environment)
       res << before.value
       mid = @mid.perform(environment)
-      res << (mid.is_a?(Sass::Script::Value::String) ? mid.value : mid.to_s)
+      res << (mid.is_a?(Sass::Script::Value::String) ? mid.value : mid.to_s(:quote => :none))
       res << @after.perform(environment).value
       opts(Sass::Script::Value::String.new(res, before.type))
     end
 
     private
 
-    def parse_str(str)
-      case str
-      when /^unquote\((["'])(.*)\1\)$/
-        return true, $1, $2
-      when '""'
-        return false, nil, ""
-      when /^(["'])(.*)\1$/
-        return false, $1, $2
-      else
-        return false, nil, str
+    def _to_sass(string_or_interp, opts)
+      result = string_or_interp.to_sass(opts)
+      opts[:quote] == :none ? result : result.slice(1...-1)
+    end
+
+    def quote_for(string_or_interp)
+      if string_or_interp.is_a?(Sass::Script::Tree::Literal)
+        return nil if string_or_interp.value.value.empty?
+        return '"' if string_or_interp.value.value.include?("'")
+        return "'" if string_or_interp.value.value.include?('"')
+        return nil
       end
+
+      # Double-quotes take precedence over single quotes.
+      before_quote = quote_for(string_or_interp.before)
+      return '"' if before_quote == '"'
+      after_quote = quote_for(string_or_interp.after)
+      return '"' if after_quote == '"'
+
+      # Returns "'" if either or both insist on single quotes, and nil
+      # otherwise.
+      before_quote || after_quote
     end
   end
 end

data/lib/sass/script/tree/variable.rb

@@ -14,7 +14,7 @@ module Sass::Script::Tree
     # @param name [String] See \{#name}
     def initialize(name)
       @name = name
-      @underscored_name = name.gsub(/-/, "_")
+      @underscored_name = name.tr("-", "_")
       super()
     end
 

data/lib/sass/script/tree.rb

@@ -13,3 +13,4 @@ require 'sass/script/tree/string_interpolation'
 require 'sass/script/tree/literal'
 require 'sass/script/tree/list_literal'
 require 'sass/script/tree/map_literal'
+require 'sass/script/tree/selector'

data/lib/sass/script/value/base.rb

@@ -20,12 +20,14 @@ module Sass::Script::Value
     #
     # @param value [Object] The object for \{#value}
     def initialize(value = nil)
-      @value = value.freeze
+      value.freeze unless value.nil? || value == true || value == false
+      @value = value
+      @options = nil
     end
 
     # Sets the options hash for this node,
     # as well as for all child nodes.
-    # See {file:SASS_REFERENCE.md#sass_options the Sass options documentation}.
+    # See {file:SASS_REFERENCE.md#Options the Sass options documentation}.
     #
     # @param options [{Symbol => Object}] The options
     attr_writer :options
@@ -86,7 +88,7 @@ MSG
     # @return [Script::Value::String] A string containing both values
     #   separated by `"="`
     def single_eq(other)
-      Sass::Script::Value::String.new("#{to_s}=#{other.to_s}")
+      Sass::Script::Value::String.new("#{self}=#{other}")
     end
 
     # The SassScript `+` operation.
@@ -95,10 +97,8 @@ MSG
     # @return [Script::Value::String] A string containing both values
     #   without any separation
     def plus(other)
-      if other.is_a?(Sass::Script::Value::String)
-        return Sass::Script::Value::String.new(to_s + other.value, other.type)
-      end
-      Sass::Script::Value::String.new(to_s + other.to_s)
+      type = other.is_a?(Sass::Script::Value::String) ? other.type : :identifier
+      Sass::Script::Value::String.new(to_s(:quote => :none) + other.to_s(:quote => :none), type)
     end
 
     # The SassScript `-` operation.
@@ -107,7 +107,7 @@ MSG
     # @return [Script::Value::String] A string containing both values
     #   separated by `"-"`
     def minus(other)
-      Sass::Script::Value::String.new("#{to_s}-#{other.to_s}")
+      Sass::Script::Value::String.new("#{self}-#{other}")
     end
 
     # The SassScript `/` operation.
@@ -116,7 +116,7 @@ MSG
     # @return [Script::Value::String] A string containing both values
     #   separated by `"/"`
     def div(other)
-      Sass::Script::Value::String.new("#{to_s}/#{other.to_s}")
+      Sass::Script::Value::String.new("#{self}/#{other}")
     end
 
     # The SassScript unary `+` operation (e.g. `+$a`).
@@ -125,7 +125,7 @@ MSG
     # @return [Script::Value::String] A string containing the value
     #   preceded by `"+"`
     def unary_plus
-      Sass::Script::Value::String.new("+#{to_s}")
+      Sass::Script::Value::String.new("+#{self}")
     end
 
     # The SassScript unary `-` operation (e.g. `-$a`).
@@ -134,7 +134,7 @@ MSG
     # @return [Script::Value::String] A string containing the value
     #   preceded by `"-"`
     def unary_minus
-      Sass::Script::Value::String.new("-#{to_s}")
+      Sass::Script::Value::String.new("-#{self}")
     end
 
     # The SassScript unary `/` operation (e.g. `/$a`).
@@ -143,13 +143,13 @@ MSG
     # @return [Script::Value::String] A string containing the value
     #   preceded by `"/"`
     def unary_div
-      Sass::Script::Value::String.new("/#{to_s}")
+      Sass::Script::Value::String.new("/#{self}")
     end
 
     # Returns the hash code of this value. Two objects' hash codes should be
     # equal if the objects are equal.
     #
-    # @return [Fixnum] The hash code.
+    # @return [Integer for Ruby 2.4.0+, Fixnum for earlier Ruby versions] The hash code.
     def hash
       value.hash
     end
@@ -176,7 +176,7 @@ MSG
       eq(other).to_bool
     end
 
-    # @return [Fixnum] The integer value of this value
+    # @return [Integer] The integer value of this value
     # @raise [Sass::SyntaxError] if this value isn't an integer
     def to_i
       raise Sass::SyntaxError.new("#{inspect} is not an integer.")
@@ -212,6 +212,9 @@ MSG
     # Returns the string representation of this value
     # as it would be output to the CSS document.
     #
+    # @options opts :quote [String]
+    #   The preferred quote style for quoted strings. If `:none`, strings are
+    #   always emitted unquoted.
     # @return [String]
     def to_s(opts = {})
       Sass::Util.abstract(self)

data/lib/sass/script/value/bool.rb

@@ -20,11 +20,6 @@ module Sass::Script::Value
       value ? TRUE : FALSE
     end
 
-    def eq(other)
-      return other.eq(self) if other.is_a?(DeprecatedFalse)
-      super
-    end
-
     # The Ruby value of the boolean.
     #
     # @return [Boolean]