aliddle-sass 1.0

data/lib/sass/scss/rx.rb

@@ -0,0 +1,133 @@
+module Sass
+  module SCSS
+    # A module containing regular expressions used
+    # for lexing tokens in an SCSS document.
+    # Most of these are taken from [the CSS3 spec](http://www.w3.org/TR/css3-syntax/#lexical),
+    # although some have been modified for various reasons.
+    module RX
+      # Takes a string and returns a CSS identifier
+      # that will have the value of the given string.
+      #
+      # @param str [String] The string to escape
+      # @return [String] The escaped string
+      def self.escape_ident(str)
+        return "" if str.empty?
+        return "\\#{str}" if str == '-' || str == '_'
+        out = ""
+        value = str.dup
+        out << value.slice!(0...1) if value =~ /^[-_]/
+        if value[0...1] =~ NMSTART
+          out << value.slice!(0...1)
+        else
+          out << escape_char(value.slice!(0...1))
+        end
+        out << value.gsub(/[^a-zA-Z0-9_-]/) {|c| escape_char c}
+        return out
+      end
+
+      # Escapes a single character for a CSS identifier.
+      #
+      # @param c [String] The character to escape. Should have length 1
+      # @return [String] The escaped character
+      # @private
+      def self.escape_char(c)
+        return "\\%06x" % Sass::Util.ord(c) unless c =~ /[ -\/:-~]/
+        return "\\#{c}"
+      end
+
+      # Creates a Regexp from a plain text string,
+      # escaping all significant characters.
+      #
+      # @param str [String] The text of the regexp
+      # @param flags [Fixnum] Flags for the created regular expression
+      # @return [Regexp]
+      # @private
+      def self.quote(str, flags = 0)
+        Regexp.new(Regexp.quote(str), flags)
+      end
+
+      H        = /[0-9a-fA-F]/
+      NL       = /\n|\r\n|\r|\f/
+      UNICODE  = /\\#{H}{1,6}[ \t\r\n\f]?/
+      s = if Sass::Util.ruby1_8?
+            '\200-\377'
+          elsif Sass::Util.macruby?
+            '\u0080-\uD7FF\uE000-\uFFFD\U00010000-\U0010FFFF'
+          else
+            '\u{80}-\u{D7FF}\u{E000}-\u{FFFD}\u{10000}-\u{10FFFF}'
+          end
+      NONASCII = /[#{s}]/
+      ESCAPE   = /#{UNICODE}|\\[ -~#{s}]/
+      NMSTART  = /[_a-zA-Z]|#{NONASCII}|#{ESCAPE}/
+      NMCHAR   = /[a-zA-Z0-9_-]|#{NONASCII}|#{ESCAPE}/
+      STRING1  = /\"((?:[^\n\r\f\\"]|\\#{NL}|#{ESCAPE})*)\"/
+      STRING2  = /\'((?:[^\n\r\f\\']|\\#{NL}|#{ESCAPE})*)\'/
+
+      IDENT    = /-?#{NMSTART}#{NMCHAR}*/
+      NAME     = /#{NMCHAR}+/
+      NUM      = /[0-9]+|[0-9]*\.[0-9]+/
+      STRING   = /#{STRING1}|#{STRING2}/
+      URLCHAR  = /[#%&*-~]|#{NONASCII}|#{ESCAPE}/
+      URL      = /(#{URLCHAR}*)/
+      W        = /[ \t\r\n\f]*/
+      VARIABLE = /(\$)(#{Sass::SCSS::RX::IDENT})/
+
+      # This is more liberal than the spec's definition,
+      # but that definition didn't work well with the greediness rules
+      RANGE    = /(?:#{H}|\?){1,6}/
+
+      ##
+
+      S = /[ \t\r\n\f]+/
+
+      COMMENT = /\/\*[^*]*\*+(?:[^\/][^*]*\*+)*\//
+      SINGLE_LINE_COMMENT = /\/\/.*(\n[ \t]*\/\/.*)*/
+
+      CDO            = quote("<!--")
+      CDC            = quote("-->")
+      INCLUDES       = quote("~=")
+      DASHMATCH      = quote("|=")
+      PREFIXMATCH    = quote("^=")
+      SUFFIXMATCH    = quote("$=")
+      SUBSTRINGMATCH = quote("*=")
+
+      HASH = /##{NAME}/
+
+      IMPORTANT = /!#{W}important/i
+      DEFAULT = /!#{W}default/i
+
+      NUMBER = /#{NUM}(?:#{IDENT}|%)?/
+
+      URI = /url\(#{W}(?:#{STRING}|#{URL})#{W}\)/i
+      FUNCTION = /#{IDENT}\(/
+
+      UNICODERANGE = /u\+(?:#{H}{1,6}-#{H}{1,6}|#{RANGE})/i
+
+      # Defined in http://www.w3.org/TR/css3-selectors/#lex
+      PLUS = /#{W}\+/
+      GREATER = /#{W}>/
+      TILDE = /#{W}~/
+      NOT = quote(":not(", Regexp::IGNORECASE)
+
+      # Defined in https://developer.mozilla.org/en/CSS/@-moz-document as a
+      # non-standard version of http://www.w3.org/TR/css3-conditional/
+      URL_PREFIX = /url-prefix\(#{W}(?:#{STRING}|#{URL})#{W}\)/i
+      DOMAIN = /domain\(#{W}(?:#{STRING}|#{URL})#{W}\)/i
+
+      # Custom
+      HEXCOLOR = /\#[0-9a-fA-F]+/
+      INTERP_START = /#\{/
+      ANY = /:(-[-\w]+-)?any\(/i
+      OPTIONAL = /!#{W}optional/i
+
+      IDENT_HYPHEN_INTERP = /-(#\{)/
+      STRING1_NOINTERP = /\"((?:[^\n\r\f\\"#]|#(?!\{)|\\#{NL}|#{ESCAPE})*)\"/
+      STRING2_NOINTERP = /\'((?:[^\n\r\f\\'#]|#(?!\{)|\\#{NL}|#{ESCAPE})*)\'/
+      STRING_NOINTERP = /#{STRING1_NOINTERP}|#{STRING2_NOINTERP}/
+
+      STATIC_COMPONENT = /#{IDENT}|#{STRING_NOINTERP}|#{HEXCOLOR}|[+-]?#{NUMBER}|\!important/i
+      STATIC_VALUE = /#{STATIC_COMPONENT}(\s*[\s,\/]\s*#{STATIC_COMPONENT})*([;}])/i
+      STATIC_SELECTOR = /(#{NMCHAR}|[ \t]|[,>+*]|[:#.]#{NMSTART}){0,50}([{])/i
+    end
+  end
+end

data/lib/sass/scss/script_lexer.rb

@@ -0,0 +1,15 @@
+module Sass
+  module SCSS
+    # A mixin for subclasses of {Sass::Script::Lexer}
+    # that makes them usable by {SCSS::Parser} to parse SassScript.
+    # In particular, the lexer doesn't support `!` for a variable prefix.
+    module ScriptLexer
+      private
+
+      def variable
+        return [:raw, "!important"] if scan(Sass::SCSS::RX::IMPORTANT)
+        _variable(Sass::SCSS::RX::VARIABLE)
+      end
+    end
+  end
+end

data/lib/sass/scss/script_parser.rb

@@ -0,0 +1,25 @@
+module Sass
+  module SCSS
+    # A mixin for subclasses of {Sass::Script::Parser}
+    # that makes them usable by {SCSS::Parser} to parse SassScript.
+    # In particular, the parser won't raise an error
+    # when there's more content in the lexer once lexing is done.
+    # In addition, the parser doesn't support `!` for a variable prefix.
+    module ScriptParser
+      private
+
+      # @private
+      def lexer_class
+        klass = Class.new(super)
+        klass.send(:include, ScriptLexer)
+        klass
+      end
+
+      # Instead of raising an error when the parser is done,
+      # rewind the StringScanner so that it hasn't consumed the final token.
+      def assert_done
+        @lexer.unpeek!
+      end
+    end
+  end
+end

data/lib/sass/scss/static_parser.rb

@@ -0,0 +1,54 @@
+require 'sass/script/css_parser'
+
+module Sass
+  module SCSS
+    # A parser for a static SCSS tree.
+    # Parses with SCSS extensions, like nested rules and parent selectors,
+    # but without dynamic SassScript.
+    # This is useful for e.g. \{#parse\_selector parsing selectors}
+    # after resolving the interpolation.
+    class StaticParser < Parser
+      # Parses the text as a selector.
+      #
+      # @param filename [String, nil] The file in which the selector appears,
+      #   or nil if there is no such file.
+      #   Used for error reporting.
+      # @return [Selector::CommaSequence] The parsed selector
+      # @raise [Sass::SyntaxError] if there's a syntax error in the selector
+      def parse_selector
+        init_scanner!
+        seq = expr!(:selector_comma_sequence)
+        expected("selector") unless @scanner.eos?
+        seq.line = @line
+        seq.filename = @filename
+        seq
+      end
+
+      private
+
+      def moz_document_function
+        return unless val = tok(URI) || tok(URL_PREFIX) || tok(DOMAIN) ||
+          function(!:allow_var)
+        ss
+        [val]
+      end
+
+      def variable; nil; end
+      def script_value; nil; end
+      def interpolation; nil; end
+      def var_expr; nil; end
+      def interp_string; s = tok(STRING) and [s]; end
+      def interp_uri; s = tok(URI) and [s]; end
+      def interp_ident(ident = IDENT); s = tok(ident) and [s]; end
+      def use_css_import?; true; end
+
+      def special_directive(name)
+        return unless %w[media import charset -moz-document].include?(name)
+        super
+      end
+
+      @sass_script_parser = Class.new(Sass::Script::CssParser)
+      @sass_script_parser.send(:include, ScriptParser)
+    end
+  end
+end

data/lib/sass/selector.rb

@@ -0,0 +1,452 @@
+require 'sass/selector/simple'
+require 'sass/selector/abstract_sequence'
+require 'sass/selector/comma_sequence'
+require 'sass/selector/sequence'
+require 'sass/selector/simple_sequence'
+
+module Sass
+  # A namespace for nodes in the parse tree for selectors.
+  #
+  # {CommaSequence} is the toplevel seelctor,
+  # representing a comma-separated sequence of {Sequence}s,
+  # such as `foo bar, baz bang`.
+  # {Sequence} is the next level,
+  # representing {SimpleSequence}s separated by combinators (e.g. descendant or child),
+  # such as `foo bar` or `foo > bar baz`.
+  # {SimpleSequence} is a sequence of selectors that all apply to a single element,
+  # such as `foo.bar[attr=val]`.
+  # Finally, {Simple} is the superclass of the simplest selectors,
+  # such as `.foo` or `#bar`.
+  module Selector
+    # The base used for calculating selector specificity. The spec says this
+    # should be "sufficiently high"; it's extremely unlikely that any single
+    # selector sequence will contain 1,000 simple selectors.
+    #
+    # @type [Fixnum]
+    SPECIFICITY_BASE = 1_000
+
+    # A parent-referencing selector (`&` in Sass).
+    # The function of this is to be replaced by the parent selector
+    # in the nested hierarchy.
+    class Parent < Simple
+      # @see Selector#to_a
+      def to_a
+        ["&"]
+      end
+
+      # Always raises an exception.
+      #
+      # @raise [Sass::SyntaxError] Parent selectors should be resolved before unification
+      # @see Selector#unify
+      def unify(sels)
+        raise Sass::SyntaxError.new("[BUG] Cannot unify parent selectors.")
+      end
+    end
+
+    # A class selector (e.g. `.foo`).
+    class Class < Simple
+      # The class name.
+      #
+      # @return [Array<String, Sass::Script::Node>]
+      attr_reader :name
+
+      # @param name [Array<String, Sass::Script::Node>] The class name
+      def initialize(name)
+        @name = name
+      end
+
+      # @see Selector#to_a
+      def to_a
+        [".", *@name]
+      end
+
+      # @see AbstractSequence#specificity
+      def specificity
+        SPECIFICITY_BASE
+      end
+    end
+
+    # An id selector (e.g. `#foo`).
+    class Id < Simple
+      # The id name.
+      #
+      # @return [Array<String, Sass::Script::Node>]
+      attr_reader :name
+
+      # @param name [Array<String, Sass::Script::Node>] The id name
+      def initialize(name)
+        @name = name
+      end
+
+      # @see Selector#to_a
+      def to_a
+        ["#", *@name]
+      end
+
+      # Returns `nil` if `sels` contains an {Id} selector
+      # with a different name than this one.
+      #
+      # @see Selector#unify
+      def unify(sels)
+        return if sels.any? {|sel2| sel2.is_a?(Id) && self.name != sel2.name}
+        super
+      end
+
+      # @see AbstractSequence#specificity
+      def specificity
+        SPECIFICITY_BASE**2
+      end
+    end
+
+    # A placeholder selector (e.g. `%foo`).
+    # This exists to be replaced via `@extend`.
+    # Rulesets using this selector will not be printed, but can be extended.
+    # Otherwise, this acts just like a class selector.
+    class Placeholder < Simple
+      # The placeholder name.
+      #
+      # @return [Array<String, Sass::Script::Node>]
+      attr_reader :name
+
+      # @param name [Array<String, Sass::Script::Node>] The placeholder name
+      def initialize(name)
+        @name = name
+      end
+
+      # @see Selector#to_a
+      def to_a
+        ["%", *@name]
+      end
+
+      # @see AbstractSequence#specificity
+      def specificity
+        0
+      end
+    end
+
+    # A universal selector (`*` in CSS).
+    class Universal < Simple
+      # The selector namespace.
+      # `nil` means the default namespace,
+      # `[""]` means no namespace,
+      # `["*"]` means any namespace.
+      #
+      # @return [Array<String, Sass::Script::Node>, nil]
+      attr_reader :namespace
+
+      # @param namespace [Array<String, Sass::Script::Node>, nil] See \{#namespace}
+      def initialize(namespace)
+        @namespace = namespace
+      end
+
+      # @see Selector#to_a
+      def to_a
+        @namespace ? @namespace + ["|*"] : ["*"]
+      end
+
+      # Unification of a universal selector is somewhat complicated,
+      # especially when a namespace is specified.
+      # If there is no namespace specified
+      # or any namespace is specified (namespace `"*"`),
+      # then `sel` is returned without change
+      # (unless it's empty, in which case `"*"` is required).
+      #
+      # If a namespace is specified
+      # but `sel` does not specify a namespace,
+      # then the given namespace is applied to `sel`,
+      # either by adding this {Universal} selector
+      # or applying this namespace to an existing {Element} selector.
+      #
+      # If both this selector *and* `sel` specify namespaces,
+      # those namespaces are unified via {Simple#unify_namespaces}
+      # and the unified namespace is used, if possible.
+      #
+      # @todo There are lots of cases that this documentation specifies;
+      #   make sure we thoroughly test **all of them**.
+      # @todo Keep track of whether a default namespace has been declared
+      #   and handle namespace-unspecified selectors accordingly.
+      # @todo If any branch of a CommaSequence ends up being just `"*"`,
+      #   then all other branches should be eliminated
+      #
+      # @see Selector#unify
+      def unify(sels)
+        name =
+          case sels.first
+          when Universal; :universal
+          when Element; sels.first.name
+          else
+            return [self] + sels unless namespace.nil? || namespace == ['*']
+            return sels unless sels.empty?
+            return [self]
+          end
+
+        ns, accept = unify_namespaces(namespace, sels.first.namespace)
+        return unless accept
+        [name == :universal ? Universal.new(ns) : Element.new(name, ns)] + sels[1..-1]
+      end
+
+      # @see AbstractSequence#specificity
+      def specificity
+        0
+      end
+    end
+
+    # An element selector (e.g. `h1`).
+    class Element < Simple
+      # The element name.
+      #
+      # @return [Array<String, Sass::Script::Node>]
+      attr_reader :name
+
+      # The selector namespace.
+      # `nil` means the default namespace,
+      # `[""]` means no namespace,
+      # `["*"]` means any namespace.
+      #
+      # @return [Array<String, Sass::Script::Node>, nil]
+      attr_reader :namespace
+
+      # @param name [Array<String, Sass::Script::Node>] The element name
+      # @param namespace [Array<String, Sass::Script::Node>, nil] See \{#namespace}
+      def initialize(name, namespace)
+        @name = name
+        @namespace = namespace
+      end
+
+      # @see Selector#to_a
+      def to_a
+        @namespace ? @namespace + ["|"] + @name : @name
+      end
+
+      # Unification of an element selector is somewhat complicated,
+      # especially when a namespace is specified.
+      # First, if `sel` contains another {Element} with a different \{#name},
+      # then the selectors can't be unified and `nil` is returned.
+      #
+      # Otherwise, if `sel` doesn't specify a namespace,
+      # or it specifies any namespace (via `"*"`),
+      # then it's returned with this element selector
+      # (e.g. `.foo` becomes `a.foo` or `svg|a.foo`).
+      # Similarly, if this selector doesn't specify a namespace,
+      # the namespace from `sel` is used.
+      #
+      # If both this selector *and* `sel` specify namespaces,
+      # those namespaces are unified via {Simple#unify_namespaces}
+      # and the unified namespace is used, if possible.
+      #
+      # @todo There are lots of cases that this documentation specifies;
+      #   make sure we thoroughly test **all of them**.
+      # @todo Keep track of whether a default namespace has been declared
+      #   and handle namespace-unspecified selectors accordingly.
+      #
+      # @see Selector#unify
+      def unify(sels)
+        case sels.first
+        when Universal;
+        when Element; return unless name == sels.first.name
+        else return [self] + sels
+        end
+
+        ns, accept = unify_namespaces(namespace, sels.first.namespace)
+        return unless accept
+        [Element.new(name, ns)] + sels[1..-1]
+      end
+
+      # @see AbstractSequence#specificity
+      def specificity
+        1
+      end
+    end
+
+    # Selector interpolation (`#{}` in Sass).
+    class Interpolation < Simple
+      # The script to run.
+      #
+      # @return [Sass::Script::Node]
+      attr_reader :script
+
+      # @param script [Sass::Script::Node] The script to run
+      def initialize(script)
+        @script = script
+      end
+
+      # @see Selector#to_a
+      def to_a
+        [@script]
+      end
+
+      # Always raises an exception.
+      #
+      # @raise [Sass::SyntaxError] Interpolation selectors should be resolved before unification
+      # @see Selector#unify
+      def unify(sels)
+        raise Sass::SyntaxError.new("[BUG] Cannot unify interpolation selectors.")
+      end
+    end
+
+    # An attribute selector (e.g. `[href^="http://"]`).
+    class Attribute < Simple
+      # The attribute name.
+      #
+      # @return [Array<String, Sass::Script::Node>]
+      attr_reader :name
+
+      # The attribute namespace.
+      # `nil` means the default namespace,
+      # `[""]` means no namespace,
+      # `["*"]` means any namespace.
+      #
+      # @return [Array<String, Sass::Script::Node>, nil]
+      attr_reader :namespace
+
+      # The matching operator, e.g. `"="` or `"^="`.
+      #
+      # @return [String]
+      attr_reader :operator
+
+      # The right-hand side of the operator.
+      #
+      # @return [Array<String, Sass::Script::Node>]
+      attr_reader :value
+
+      # Flags for the attribute selector (e.g. `i`).
+      #
+      # @return [Array<String, Sass::Script::Node>]
+      attr_reader :flags
+
+      # @param name [Array<String, Sass::Script::Node>] The attribute name
+      # @param namespace [Array<String, Sass::Script::Node>, nil] See \{#namespace}
+      # @param operator [String] The matching operator, e.g. `"="` or `"^="`
+      # @param value [Array<String, Sass::Script::Node>] See \{#value}
+      # @param value [Array<String, Sass::Script::Node>] See \{#flags}
+      def initialize(name, namespace, operator, value, flags)
+        @name = name
+        @namespace = namespace
+        @operator = operator
+        @value = value
+        @flags = flags
+      end
+
+      # @see Selector#to_a
+      def to_a
+        res = ["["]
+        res.concat(@namespace) << "|" if @namespace
+        res.concat @name
+        (res << @operator).concat @value if @value
+        (res << " ").concat @flags if @flags
+        res << "]"
+      end
+
+      # @see AbstractSequence#specificity
+      def specificity
+        SPECIFICITY_BASE
+      end
+    end
+
+    # A pseudoclass (e.g. `:visited`) or pseudoelement (e.g. `::first-line`) selector.
+    # It can have arguments (e.g. `:nth-child(2n+1)`).
+    class Pseudo < Simple
+      # Some psuedo-class-syntax selectors are actually considered
+      # pseudo-elements and must be treated differently. This is a list of such
+      # selectors
+      #
+      # @return [Array<String>]
+      ACTUALLY_ELEMENTS = %w[after before first-line first-letter]
+
+      # Like \{#type}, but returns the type of selector this looks like, rather
+      # than the type it is semantically. This only differs from type for
+      # selectors in \{ACTUALLY\_ELEMENTS}.
+      #
+      # @return [Symbol]
+      attr_reader :syntactic_type
+
+      # The name of the selector.
+      #
+      # @return [Array<String, Sass::Script::Node>]
+      attr_reader :name
+
+      # The argument to the selector,
+      # or `nil` if no argument was given.
+      #
+      # This may include SassScript nodes that will be run during resolution.
+      # Note that this should not include SassScript nodes
+      # after resolution has taken place.
+      #
+      # @return [Array<String, Sass::Script::Node>, nil]
+      attr_reader :arg
+
+      # @param type [Symbol] See \{#type}
+      # @param name [Array<String, Sass::Script::Node>] The name of the selector
+      # @param arg [nil, Array<String, Sass::Script::Node>] The argument to the selector,
+      #   or nil if no argument was given
+      def initialize(type, name, arg)
+        @syntactic_type = type
+        @name = name
+        @arg = arg
+      end
+
+      # The type of the selector. `:class` if this is a pseudoclass selector,
+      # `:element` if it's a pseudoelement.
+      #
+      # @return [Symbol]
+      def type
+        ACTUALLY_ELEMENTS.include?(name.first) ? :element : syntactic_type
+      end
+
+      # @see Selector#to_a
+      def to_a
+        res = [syntactic_type == :class ? ":" : "::"] + @name
+        (res << "(").concat(Sass::Util.strip_string_array(@arg)) << ")" if @arg
+        res
+      end
+
+      # Returns `nil` if this is a pseudoelement selector
+      # and `sels` contains a pseudoelement selector different than this one.
+      #
+      # @see Selector#unify
+      def unify(sels)
+        return if type == :element && sels.any? do |sel|
+          sel.is_a?(Pseudo) && sel.type == :element &&
+            (sel.name != self.name || sel.arg != self.arg)
+        end
+        super
+      end
+
+      # @see AbstractSequence#specificity
+      def specificity
+        type == :class ? SPECIFICITY_BASE : 1
+      end
+    end
+
+    # A pseudoclass selector whose argument is itself a selector
+    # (e.g. `:not(.foo)` or `:-moz-all(.foo, .bar)`).
+    class SelectorPseudoClass < Simple
+      # The name of the pseudoclass.
+      #
+      # @return [String]
+      attr_reader :name
+
+      # The selector argument.
+      #
+      # @return [Selector::Sequence]
+      attr_reader :selector
+
+      # @param [String] The name of the pseudoclass
+      # @param [Selector::CommaSequence] The selector argument
+      def initialize(name, selector)
+        @name = name
+        @selector = selector
+      end
+
+      # @see Selector#to_a
+      def to_a
+        [":", @name, "("] + @selector.to_a + [")"]
+      end
+
+      # @see AbstractSequence#specificity
+      def specificity
+        SPECIFICITY_BASE
+      end
+    end
+  end
+end