sass 3.2.0.alpha.57 → 3.2.0.alpha.59

data/REVISION

@@ -1 +1 @@
-a9d57b52dc7bfa8a777cf22d6ca36645855757ce
+77d6cfe978e5d2d28ee6126e207e19b86b661c27

data/VERSION

@@ -1 +1 @@
-3.2.0.alpha.57
+3.2.0.alpha.59

data/lib/sass/engine.rb

@@ -39,6 +39,7 @@ require 'sass/scss'
 require 'sass/error'
 require 'sass/importers'
 require 'sass/shared'
+require 'sass/media'
 
 module Sass
 
@@ -223,7 +224,7 @@ module Sass
     # If you're compiling a single Sass file from the filesystem,
     # use \{Sass::Engine.for\_file}.
     # If you're compiling multiple files from the filesystem,
-    # use {Sass::Plugin.
+    # use {Sass::Plugin}.
     #
     # @param template [String] The Sass template.
     #   This template can be encoded using any encoding
@@ -639,7 +640,7 @@ WARNING
       # If value begins with url( or ",
       # it's a CSS @import rule and we don't want to touch it.
       if directive == "import"
-        parse_import(line, value)
+        parse_import(line, value, offset)
       elsif directive == "mixin"
         parse_mixin_definition(line)
       elsif directive == "content"
@@ -691,9 +692,11 @@ WARNING
           :line => @line + 1) unless line.children.empty?
         Tree::CharsetNode.new(name)
       elsif directive == "media"
-        Tree::MediaNode.new(value.split(',').map {|s| s.strip})
+        parser = Sass::SCSS::SassParser.new(value, @options[:filename], @line)
+        Tree::MediaNode.new(parser.parse_media_query_list)
       else
-        Tree::DirectiveNode.new(line.text)
+        Tree::DirectiveNode.new(
+          value.nil? ? ["@#{directive}"] : ["@#{directive} "] + parse_interp(value, offset))
       end
     end
 
@@ -753,7 +756,7 @@ WARNING
       nil
     end
 
-    def parse_import(line, value)
+    def parse_import(line, value, offset)
       raise SyntaxError.new("Illegal nesting: Nothing may be nested beneath import directives.",
         :line => @line + 1) unless line.children.empty?
 
@@ -761,7 +764,7 @@ WARNING
       values = []
 
       loop do
-        unless node = parse_import_arg(scanner)
+        unless node = parse_import_arg(scanner, offset + scanner.pos)
           raise SyntaxError.new("Invalid @import: expected file to import, was #{scanner.rest.inspect}",
             :line => @line)
         end
@@ -777,21 +780,27 @@ WARNING
       return values
     end
 
-    def parse_import_arg(scanner)
+    def parse_import_arg(scanner, offset)
       return if scanner.eos?
-      unless (str = scanner.scan(Sass::SCSS::RX::STRING)) ||
-          (uri = scanner.scan(Sass::SCSS::RX::URI))
+
+      if scanner.match?(/url\(/i)
+        parser = Sass::Script::Parser.new(scanner, @line, offset, @options)
+        str = parser.parse_string
+        media = scanner.scan(/\s*[^,;].*/)
+        media &&= " #{media}"
+        return Tree::DirectiveNode.new(["@import ", str, media || ''])
+      end
+
+      unless str = scanner.scan(Sass::SCSS::RX::STRING)
         return Tree::ImportNode.new(scanner.scan(/[^,;]+/))
       end
 
       val = scanner[1] || scanner[2]
       scanner.scan(/\s*/)
       if media = scanner.scan(/[^,;].*/)
-        Tree::DirectiveNode.new("@import #{str || uri} #{media}")
-      elsif uri
-        Tree::DirectiveNode.new("@import #{uri}")
+        Tree::DirectiveNode.new(["@import #{str || uri} #{media}"])
       elsif val =~ /^http:\/\//
-        Tree::DirectiveNode.new("@import url(#{val})")
+        Tree::DirectiveNode.new(["@import url(#{val})"])
       else
         Tree::ImportNode.new(val)
       end

data/lib/sass/media.rb

@@ -0,0 +1,300 @@
+# 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
+
+    # Runs the SassScript in the media query list.
+    #
+    # @yield [interp] A block that should perform interpolation.
+    # @yieldparam interp [Array<String, Sass::Script::Node>]
+    #   An interpolation array to perform.
+    # @yieldreturn [String] The interpolated value.
+    def perform(&run_interp)
+      @queries.each {|q| q.perform(&run_interp)}
+    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 deep copy of this query list and all its children.
+    #
+    # @return [QueryList]
+    def deep_copy
+      QueryList.new(queries.map {|q| q.deep_copy})
+    end
+
+    # Sets the options hash for the script nodes in the media query.
+    #
+    # @param options [{Symbol => Object}] The options has to set.
+    def options=(options)
+      queries.each {|q| q.options = options}
+    end
+  end
+
+  # A single media query.
+  #
+  #   [ [ONLY | NOT]? S* media_type S* | expression ] [ AND S* expression ]*
+  class Query
+    # The modifier for the query.
+    #
+    # @return [Array<String, Sass::Script::Node>]
+    attr_accessor :modifier
+
+    # The modifier for the query after any SassScript has been resolved.
+    # Only set once \{Tree::Visitors::Perform} has been run.
+    #
+    # @return [String]
+    attr_accessor :resolved_modifier
+
+    # The type of the query (e.g. `"screen"` or `"print"`).
+    #
+    # @return [Array<String, Sass::Script::Node>]
+    attr_accessor :type
+
+    # The type of the query after any SassScript has been resolved.
+    # Only set once \{Tree::Visitors::Perform} has been run.
+    #
+    # @return [String]
+    attr_accessor :resolved_type
+
+    # The trailing expressions in the query.
+    #
+    # @return [Array<Expression>]
+    attr_accessor :expressions
+
+    # @param modifier [Array<String, Sass::Script::Node>] See \{#modifier}
+    # @param type [Array<String, Sass::Script::Node>] See \{#type}
+    # @param expressions [Array<Expression>] See \{#expressions}
+    def initialize(modifier, type, expressions)
+      @modifier = modifier
+      @type = type
+      @expressions = expressions
+    end
+
+    # Runs the SassScript in the media query.
+    #
+    # @yield [interp] A block that should perform interpolation.
+    # @yieldparam interp [Array<String, Sass::Script::Node>]
+    #   An interpolation array to perform.
+    # @yieldreturn [String] The interpolated value.
+    def perform(&run_interp)
+      @resolved_modifier = yield modifier
+      @resolved_type = yield type
+      expressions.each {|e| e.perform(&run_interp)}
+    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
+      q = Query.new([], [], other.expressions + expressions)
+      q.resolved_type = type
+      q.resolved_modifier = mod
+      return q
+    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 {|e| e.to_css}.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_or_var_to_src(modifier, options)
+      src << ' ' unless modifier.empty?
+      src << Sass::Media._interp_or_var_to_src(type, options)
+      src << ' and ' unless type.empty? || expressions.empty?
+      src << expressions.map {|e| e.to_src(options)}.join(' and ')
+      src
+    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::Node) ? c.deep_copy : c},
+        type.map {|c| c.is_a?(Sass::Script::Node) ? c.deep_copy : c},
+        expressions.map {|q| q.deep_copy})
+    end
+
+    # Sets the options hash for the script nodes in the media query.
+    #
+    # @param options [{Symbol => Object}] The options has to set.
+    def options=(options)
+      modifier.each {|m| m.options = options if m.is_a?(Sass::Script::Node)}
+      type.each {|t| t.options = options if t.is_a?(Sass::Script::Node)}
+      expressions.each {|e| e.options = options}
+    end
+  end
+
+  # A media query expression.
+  #
+  #   '(' S* media_feature S* [ ':' S* expr ]? ')'
+  class Expression
+    # The name of the feature being queried for.
+    #
+    # @return [Array<String, Sass::Script::Node>]
+    attr_accessor :name
+
+    # The name of the feature after any SassScript has been resolved.
+    # Only set once \{Tree::Visitors::Perform} has been run.
+    #
+    # @return [String]
+    attr_accessor :resolved_name
+
+    # The value of the feature.
+    #
+    # @return [Array<String, Sass::Script::Node>]
+    attr_accessor :value
+
+    # The value of the feature after any SassScript has been resolved.
+    # Only set once \{Tree::Visitors::Perform} has been run.
+    #
+    # @return [String]
+    attr_accessor :resolved_value
+
+    # @param name [Array<String, Sass::Script::Node>] See \{#name}
+    # @param value [Array<String, Sass::Script::Node>] See \{#value}
+    def initialize(name, value)
+      @name = name
+      @value = value
+    end
+
+    # Runs the SassScript in the expression.
+    #
+    # @yield [interp] A block that should perform interpolation.
+    # @yieldparam interp [Array<String, Sass::Script::Node>]
+    #   An interpolation array to perform.
+    # @yieldreturn [String] The interpolated value.
+    def perform
+      @resolved_name = yield name
+      @resolved_value = yield value
+    end
+
+    # Returns the CSS for the expression.
+    #
+    # @return [String]
+    def to_css
+      css = '('
+      css << resolved_name
+      css << ': ' << resolved_value unless resolved_value.empty?
+      css << ')'
+      css
+    end
+
+    # Returns the Sass/SCSS code for the expression.
+    #
+    # @param options [{Symbol => Object}] An options hash (see {Sass::CSS#initialize}).
+    # @return [String]
+    def to_src(options)
+      src = '('
+      src << Sass::Media._interp_or_var_to_src(name, options)
+      src << ': ' << Sass::Media._interp_or_var_to_src(value, options) unless value.empty?
+      src << ')'
+      src
+    end
+
+    # Returns a deep copy of this expression.
+    #
+    # @return [Expression]
+    def deep_copy
+      Expression.new(
+        name.map {|c| c.is_a?(Sass::Script::Node) ? c.deep_copy : c},
+        value.map {|c| c.is_a?(Sass::Script::Node) ? c.deep_copy : c})
+    end
+
+    # Sets the options hash for the script nodes in the expression.
+    #
+    # @param options [{Symbol => Object}] The options has to set.
+    def options=(options)
+      name.each {|n| n.options = options if n.is_a?(Sass::Script::Node)}
+      value.each {|v| v.options = options if v.is_a?(Sass::Script::Node)}
+    end
+  end
+
+  # Converts an interpolation array that may represent a single variable to source.
+  #
+  # @param [Array<String, Sass::Script::Node>] The interpolation array to convert.
+  # @param options [{Symbol => Object}] An options hash (see {Sass::CSS#initialize}).
+  # @return [String]
+  def self._interp_or_var_to_src(interp, options)
+    interp = interp.reject {|v| v.is_a?(String) && v.empty?}
+    return interp[0].to_sass(options) if interp.length == 1 && interp[0].is_a?(Sass::Script::Variable)
+    interp.map do |r|
+      next r if r.is_a?(String)
+      "\#{#{r.to_sass(options)}}"
+    end.join
+  end
+end

data/lib/sass/script/funcall.rb

@@ -36,7 +36,7 @@ module Sass
       # @return [String] A string representation of the function call
       def inspect
         args = @args.map {|a| a.inspect}.join(', ')
-        keywords = @keywords.sort_by {|k, v| k}.
+        keywords = Sass::Util.hash_to_a(@keywords).
             map {|k, v| "$#{k}: #{v.inspect}"}.join(', ')
         "#{name}(#{args}#{', ' unless args.empty? || keywords.empty?}#{keywords})"
       end
@@ -44,7 +44,7 @@ module Sass
       # @see Node#to_sass
       def to_sass(opts = {})
         args = @args.map {|a| a.to_sass(opts)}.join(', ')
-        keywords = @keywords.sort_by {|k, v| k}.
+        keywords = Sass::Util.hash_to_a(@keywords).
           map {|k, v| "$#{dasherize(k, opts)}: #{v.to_sass(opts)}"}.join(', ')
         "#{dasherize(name, opts)}(#{args}#{', ' unless args.empty? || keywords.empty?}#{keywords})"
       end

data/lib/sass/script/literal.rb

@@ -55,26 +55,6 @@ The #options attribute is not set on this #{self.class}.
 MSG
     end
 
-    # The SassScript `and` operation.
-    #
-    # @param other [Literal] The right-hand side of the operator
-    # @return [Literal] The result of a logical and:
-    #   `other` if this literal isn't a false {Bool},
-    #   and this literal otherwise
-    def and(other)
-      to_bool ? other : self
-    end
-
-    # The SassScript `or` operation.
-    #
-    # @param other [Literal] The right-hand side of the operator
-    # @return [Literal] The result of the logical or:
-    #   this literal if it isn't a false {Bool},
-    #   and `other` otherwise
-    def or(other)
-      to_bool ? self : other
-    end
-
     # The SassScript `==` operation.
     # **Note that this returns a {Sass::Script::Bool} object,
     # not a Ruby boolean**.

data/lib/sass/script/operation.rb

@@ -72,6 +72,14 @@ module Sass::Script
     # @raise [Sass::SyntaxError] if the operation is undefined for the operands
     def _perform(environment)
       literal1 = @operand1.perform(environment)
+
+      # Special-case :and and :or to support short-circuiting.
+      if @operator == :and
+        return literal1.to_bool ? @operand2.perform(environment) : literal1
+      elsif @operator == :or
+        return literal1.to_bool ? literal1 : @operand2.perform(environment)
+      end
+
       literal2 = @operand2.perform(environment)
 
       begin