xass 0.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/scss.rb

@@ -0,0 +1,16 @@
+require 'sass/scss/rx'
+require 'sass/scss/script_lexer'
+require 'sass/scss/script_parser'
+require 'sass/scss/parser'
+require 'sass/scss/static_parser'
+require 'sass/scss/css_parser'
+
+module Sass
+  # SCSS is the CSS syntax for Sass.
+  # It parses into the same syntax tree as Sass,
+  # and generates the same sort of output CSS.
+  #
+  # This module contains code for the parsing of SCSS.
+  # The evaluation is handled by the broader {Sass} module.
+  module SCSS; end
+end

data/lib/sass/selector/abstract_sequence.rb

@@ -0,0 +1,94 @@
+module Sass
+  module Selector
+    # The abstract parent class of the various selector sequence classes.
+    #
+    # All subclasses should implement a `members` method that returns an array
+    # of object that respond to `#line=` and `#filename=`, as well as a `to_a`
+    # method that returns an array of strings and script nodes.
+    class AbstractSequence
+      # The line of the Sass template on which this selector was declared.
+      #
+      # @return [Fixnum]
+      attr_reader :line
+
+      # The name of the file in which this selector was declared.
+      #
+      # @return [String, nil]
+      attr_reader :filename
+
+      # Sets the line of the Sass template on which this selector was declared.
+      # This also sets the line for all child selectors.
+      #
+      # @param line [Fixnum]
+      # @return [Fixnum]
+      def line=(line)
+        members.each {|m| m.line = line}
+        @line = line
+      end
+
+      # Sets the name of the file in which this selector was declared,
+      # or `nil` if it was not declared in a file (e.g. on stdin).
+      # This also sets the filename for all child selectors.
+      #
+      # @param filename [String, nil]
+      # @return [String, nil]
+      def filename=(filename)
+        members.each {|m| m.filename = filename}
+        @filename = filename
+      end
+
+      # Returns a hash code for this sequence.
+      #
+      # Subclasses should define `#_hash` rather than overriding this method,
+      # which automatically handles memoizing the result.
+      #
+      # @return [Fixnum]
+      def hash
+        @_hash ||= _hash
+      end
+
+      # Checks equality between this and another object.
+      #
+      # Subclasses should define `#_eql?` rather than overriding this method,
+      # which handles checking class equality and hash equality.
+      #
+      # @param other [Object] The object to test equality against
+      # @return [Boolean] Whether or not this is equal to `other`
+      def eql?(other)
+        other.class == self.class && other.hash == self.hash && _eql?(other)
+      end
+      alias_method :==, :eql?
+
+      # Whether or not this selector sequence contains a placeholder selector.
+      # Checks recursively.
+      def has_placeholder?
+        @has_placeholder ||=
+          members.any? {|m| m.is_a?(AbstractSequence) ? m.has_placeholder? : m.is_a?(Placeholder)}
+      end
+
+      # Converts the selector into a string. This is the standard selector
+      # string, along with any SassScript interpolation that may exist.
+      #
+      # @return [String]
+      def to_s
+        to_a.map {|e| e.is_a?(Sass::Script::Node) ? "\#{#{e.to_sass}}" : e}.join
+      end
+
+      # Returns the specificity of the selector as an integer. The base is given
+      # by {Sass::Selector::SPECIFICITY_BASE}.
+      #
+      # @return [Fixnum]
+      def specificity
+        _specificity(members)
+      end
+
+      protected
+
+      def _specificity(arr)
+        spec = 0
+        arr.map {|m| spec += m.is_a?(String) ? 0 : m.specificity}
+        spec
+      end
+    end
+  end
+end

data/lib/sass/selector/comma_sequence.rb

@@ -0,0 +1,92 @@
+module Sass
+  module Selector
+    # A comma-separated sequence of selectors.
+    class CommaSequence < AbstractSequence
+      # The comma-separated selector sequences
+      # represented by this class.
+      #
+      # @return [Array<Sequence>]
+      attr_reader :members
+
+      # @param seqs [Array<Sequence>] See \{#members}
+      def initialize(seqs)
+        @members = seqs
+      end
+
+      # Resolves the {Parent} selectors within this selector
+      # by replacing them with the given parent selector,
+      # handling commas appropriately.
+      #
+      # @param super_cseq [CommaSequence] The parent selector
+      # @return [CommaSequence] This selector, with parent references resolved
+      # @raise [Sass::SyntaxError] If a parent selector is invalid
+      def resolve_parent_refs(super_cseq)
+        if super_cseq.nil?
+          if @members.any? do |sel|
+              sel.members.any? do |sel_or_op|
+                sel_or_op.is_a?(SimpleSequence) && sel_or_op.members.any? {|ssel| ssel.is_a?(Parent)}
+              end
+            end
+            raise Sass::SyntaxError.new("Base-level rules cannot contain the parent-selector-referencing character '&'.")
+          end
+          return self
+        end
+
+        CommaSequence.new(
+          super_cseq.members.map do |super_seq|
+            @members.map {|seq| seq.resolve_parent_refs(super_seq)}
+          end.flatten)
+      end
+
+      # Non-destrucively extends this selector with the extensions specified in a hash
+      # (which should come from {Sass::Tree::Visitors::Cssize}).
+      #
+      # @todo Link this to the reference documentation on `@extend`
+      #   when such a thing exists.
+      #
+      # @param extends [Sass::Util::SubsetMap{Selector::Simple =>
+      #                                       Sass::Tree::Visitors::Cssize::Extend}]
+      #   The extensions to perform on this selector
+      # @param parent_directives [Array<Sass::Tree::DirectiveNode>]
+      #   The directives containing this selector.
+      # @return [CommaSequence] A copy of this selector,
+      #   with extensions made according to `extends`
+      def do_extend(extends, parent_directives)
+        CommaSequence.new(members.map do |seq|
+            extended = seq.do_extend(extends, parent_directives)
+            # First Law of Extend: the result of extending a selector should
+            # always contain the base selector.
+            #
+            # See https://github.com/nex3/sass/issues/324.
+            extended.unshift seq unless seq.has_placeholder? || extended.include?(seq)
+            extended
+          end.flatten)
+      end
+
+      # Returns a string representation of the sequence.
+      # This is basically the selector string.
+      #
+      # @return [String]
+      def inspect
+        members.map {|m| m.inspect}.join(", ")
+      end
+
+      # @see Simple#to_a
+      def to_a
+        arr = Sass::Util.intersperse(@members.map {|m| m.to_a}, ", ").flatten
+        arr.delete("\n")
+        arr
+      end
+
+      private
+
+      def _hash
+        members.hash
+      end
+
+      def _eql?(other)
+        other.class == self.class && other.members.eql?(self.members)
+      end
+    end
+  end
+end