haml 3.0.0.beta.1 → 3.0.0.beta.2

data/lib/sass/scss/css_parser.rb

@@ -9,6 +9,7 @@ module Sass
       def parent_selector; nil; end
       def interpolation; nil; end
       def interp_string; tok(STRING); end
+      def interp_ident(ident = IDENT); tok(ident); end
       def expected_property_separator; '":"'; end
       def use_css_import?; true; end
 

data/lib/sass/scss/parser.rb

@@ -77,7 +77,7 @@ module Sass
         node << comment
       end
 
-      DIRECTIVES = Set[:mixin, :include, :debug, :for, :while, :if, :import, :media]
+      DIRECTIVES = Set[:mixin, :include, :debug, :warn, :for, :while, :if, :import, :media]
 
       def directive
         return unless tok(/@/)
@@ -127,6 +127,10 @@ module Sass
         node(Sass::Tree::DebugNode.new(sass_script(:parse)))
       end
 
+      def warn
+        node(Sass::Tree::WarnNode.new(sass_script(:parse)))
+      end
+
       def for
         tok!(/\$/)
         var = tok! IDENT
@@ -259,18 +263,6 @@ module Sass
         tok(/[+-]/)
       end
 
-      def property
-        return unless e = (tok(IDENT) || interpolation)
-        res = [e, str{ss}]
-
-        while e = (interpolation || tok(IDENT))
-          res << e
-        end
-
-        ss
-        res
-      end
-
       def ruleset
         rules = []
         return unless v = selector
@@ -366,12 +358,12 @@ module Sass
 
       def simple_selector_sequence
         # This allows for stuff like http://www.w3.org/TR/css3-animations/#keyframes-
-        return expr unless e = element_name || tok(HASH) || class_expr ||
+        return expr unless e = element_name || id_selector || class_selector ||
           attrib || negation || pseudo || parent_selector || interpolation
         res = [e]
 
         # The tok(/\*/) allows the "E*" hack
-        while v = element_name || tok(HASH) || class_expr ||
+        while v = element_name || id_selector || class_selector ||
             attrib || negation || pseudo || tok(/\*/) || interpolation
           res << v
         end
@@ -382,23 +374,30 @@ module Sass
         tok(/&/)
       end
 
-      def class_expr
+      def class_selector
         return unless tok(/\./)
-        '.' + tok!(IDENT)
+        @expected = "class name"
+        ['.', expr!(:interp_ident)]
+      end
+
+      def id_selector
+        return unless tok(/#(?!\{)/)
+        @expected = "id name"
+        ['#', expr!(:interp_name)]
       end
 
       def element_name
-        return unless name = tok(IDENT) || tok(/\*/) || tok?(/\|/)
+        return unless name = interp_ident || tok(/\*/) || tok?(/\|/)
         if tok(/\|/)
           @expected = "element name or *"
-          name << "|" << (tok(IDENT) || tok!(/\*/))
+          name << "|" << (interp_ident || tok!(/\*/))
         end
         name
       end
 
       def attrib
         return unless tok(/\[/)
-        res = ['[', str{ss}, str{attrib_name!}, str{ss}]
+        res = ['[', str{ss}, attrib_name!, str{ss}]
 
         if m = tok(/=/) ||
             tok(INCLUDES) ||
@@ -413,31 +412,29 @@ module Sass
       end
 
       def attrib_name!
-        if tok(IDENT)
-          # E, E|E, or E|
-          # The last is allowed so that E|="foo" will work
-          tok(IDENT) if tok(/\|/)
-        elsif tok(/\*/)
-          # *|E
-          tok!(/\|/)
-          tok! IDENT
+        if name_or_ns = interp_ident
+          # E, E|E
+          if tok(/\|(?!=)/)
+            ns = name_or_ns
+            name = interp_ident
+          else
+            name = name_or_ns
+          end
         else
-          # |E or E
-          tok(/\|/)
-          tok! IDENT
+          # *|E or |E
+          ns = tok(/\*/) || ""
+          tok!(/\|/)
+          name = expr!(:interp_ident)
         end
+        return [ns, ("|" if ns), name]
       end
 
       def pseudo
         return unless s = tok(/::?/)
-
         @expected = "pseudoclass or pseudoelement"
-        [s, functional_pseudo || tok!(IDENT)]
-      end
-
-      def functional_pseudo
-        return unless fn = tok(FUNCTION)
-        [fn, str{ss}, expr!(:pseudo_expr), tok!(/\)/)]
+        res = [s, expr!(:interp_ident)]
+        return res unless tok(/\(/)
+        res << '(' << str{ss} << expr!(:pseudo_expr) << tok!(/\)/)
       end
 
       def pseudo_expr
@@ -455,18 +452,20 @@ module Sass
         return unless tok(NOT)
         res = [":not(", str{ss}]
         @expected = "selector"
-        res << (element_name || tok(HASH) || class_expr || attrib || expr!(:pseudo))
+        res << (element_name || id_selector || class_selector || attrib || expr!(:pseudo))
         res << tok!(/\)/)
       end
 
       def declaration
         # This allows the "*prop: val", ":prop: val", and ".prop: val" hacks
-        if s = tok(/[:\*\.]/)
-          @use_property_exception = s != '.'
-          name = [s, str{ss}] + expr!(:property)
+        if s = tok(/[:\*\.]|\#(?!\{)/)
+          @use_property_exception = s !~ /[\.\#]/
+          name = [s, str{ss}, *expr!(:interp_ident)]
         else
-          return unless name = property
+          return unless name = interp_ident
+          name = [name] if name.is_a?(String)
         end
+        ss
 
         @expected = expected_property_separator
         space, value = expr!(:value)
@@ -553,7 +552,7 @@ MESSAGE
       end
 
       def interpolation
-        return unless tok(/#\{/)
+        return unless tok(INTERP_START)
         sass_script(:parse_interpolated)
       end
 
@@ -571,6 +570,19 @@ MESSAGE
         res
       end
 
+      def interp_ident(start = IDENT)
+        return unless val = tok(start) || interpolation
+        res = [val]
+        while val = tok(NAME) || interpolation
+          res << val
+        end
+        res
+      end
+
+      def interp_name
+        interp_ident NAME
+      end
+
       def str
         @strs.push ""
         yield
@@ -608,6 +620,8 @@ MESSAGE
         :media_query => "media query (e.g. print, screen, print and screen)",
         :media_expr => "media expression (e.g. (min-device-width: 800px)))",
         :pseudo_expr => "expression (e.g. fr, 2n+1)",
+        :interp_ident => "identifier",
+        :interp_name => "identifier",
         :expr => "expression (e.g. 1px, bold)",
       }
 

data/lib/sass/scss/rx.rb

@@ -107,6 +107,7 @@ module Sass
 
       # Custom
       HEXCOLOR = /\#[0-9a-fA-F]{3}(?:[0-9a-fA-F]{3})?/
+      INTERP_START = /#\{/
     end
   end
 end

data/lib/sass/tree/comment_node.rb

@@ -59,10 +59,11 @@ module Sass::Tree
         else
           content.gsub!(/\n( \*|\/\/)/, "\n  ")
           spaces = content.scan(/\n( *)/).map {|s| s.first.size}.min
+          sep = silent ? "\n//" : "\n *"
           if spaces >= 2
-            content
+            content.gsub(/\n  /, sep)
           else
-            content.gsub(/\n#{' ' * spaces}/, "\n  ")
+            content.gsub(/\n#{' ' * spaces}/, sep)
           end
         end
 

data/lib/sass/tree/debug_node.rb

@@ -13,7 +13,7 @@ module Sass
       protected
 
       def to_src(tabs, opts, fmt)
-        "#{'  ' * tabs}@debug #{@expr.to_sass}#{semi fmt}\n"
+        "#{'  ' * tabs}@debug #{@expr.to_sass(opts)}#{semi fmt}\n"
       end
 
       # Prints the expression to STDERR.

data/lib/sass/tree/for_node.rb

@@ -22,7 +22,7 @@ module Sass::Tree
 
     def to_src(tabs, opts, fmt)
       to = @exclusive ? "to" : "through"
-      "#{'  ' * tabs}@for $#{@var} from #{@from.to_sass} #{to} #{@to.to_sass}" +
+      "#{'  ' * tabs}@for $#{dasherize(@var, opts)} from #{@from.to_sass(opts)} #{to} #{@to.to_sass(opts)}" +
         children_to_src(tabs, opts, fmt)
     end
 

data/lib/sass/tree/if_node.rb

@@ -44,7 +44,7 @@ module Sass::Tree
         else; "else"
         end
       str = "#{'  ' * tabs}@#{name}"
-      str << " #{@expr.to_sass}" if @expr
+      str << " #{@expr.to_sass(opts)}" if @expr
       str << children_to_src(tabs, opts, fmt)
       str << @else.send(:to_src, tabs, opts, fmt, true) if @else
       str

data/lib/sass/tree/import_node.rb

@@ -62,6 +62,7 @@ module Sass
       # @param environment [Sass::Environment] The lexical environment containing
       #   variable and mixin values
       def perform!(environment)
+        environment.push_frame(:filename => @filename, :line => @line)
         root = Sass::Files.tree_for(full_filename, @options)
         @template = root.template
         self.children = root.children
@@ -70,6 +71,8 @@ module Sass
         e.modify_backtrace(:filename => full_filename)
         e.add_backtrace(:filename => @filename, :line => @line)
         raise e
+      ensure
+        environment.pop_frame
       end
 
       private

data/lib/sass/tree/mixin_def_node.rb

@@ -23,14 +23,14 @@ module Sass
           else
             '(' + @args.map do |v, d|
               if d
-                "#{v.to_sass}: #{d.to_sass}"
+                "#{v.to_sass(opts)}: #{d.to_sass(opts)}"
               else
-                v.to_sass
+                v.to_sass(opts)
               end
             end.join(", ") + ')'
           end
               
-        "#{'  ' * tabs}#{fmt == :sass ? '=' : '@mixin '}#{@name}#{args}" +
+        "#{'  ' * tabs}#{fmt == :sass ? '=' : '@mixin '}#{dasherize(@name, opts)}#{args}" +
           children_to_src(tabs, opts, fmt)
       end
 

data/lib/sass/tree/mixin_node.rb

@@ -29,8 +29,8 @@ module Sass::Tree
     protected
 
     def to_src(tabs, opts, fmt)
-      args = '(' + @args.map {|a| a.to_sass}.join(", ") + ')' unless @args.empty?
-      "#{'  ' * tabs}#{fmt == :sass ? '+' : '@include '}#{@name}#{args}#{semi fmt}\n"
+      args = '(' + @args.map {|a| a.to_sass(opts)}.join(", ") + ')' unless @args.empty?
+      "#{'  ' * tabs}#{fmt == :sass ? '+' : '@include '}#{dasherize(@name, opts)}#{args}#{semi fmt}\n"
     end
 
     # @see Node#_cssize
@@ -50,13 +50,15 @@ module Sass::Tree
     # @raise [Sass::SyntaxError] if an incorrect number of arguments was passed
     # @see Sass::Tree
     def perform!(environment)
+      original_env = environment
+      original_env.push_frame(:filename => filename, :line => line)
+      original_env.prepare_frame(:mixin => @name)
       raise Sass::SyntaxError.new("Undefined mixin '#{@name}'.") unless mixin = environment.mixin(@name)
 
       raise Sass::SyntaxError.new(<<END.gsub("\n", "")) if mixin.args.size < @args.size
 Mixin #{@name} takes #{mixin.args.size} argument#{'s' if mixin.args.size != 1}
  but #{@args.size} #{@args.size == 1 ? 'was' : 'were'} passed.
 END
-
       environment = mixin.args.zip(@args).
         inject(Sass::Environment.new(mixin.environment)) do |env, ((var, default), value)|
         env.set_local_var(var.name,
@@ -78,6 +80,8 @@ END
       e.modify_backtrace(:mixin => @name, :line => @line)
       e.add_backtrace(:line => @line)
       raise e
+    ensure
+      original_env.pop_frame
     end
   end
 end

data/lib/sass/tree/node.rb

@@ -366,6 +366,14 @@ module Sass
           (fmt == :sass ? "\n" : " }\n")
       end
 
+      def dasherize(s, opts)
+        if opts[:dasherize]
+          s.gsub(/_/,'-')
+        else
+          s
+        end
+      end
+
       # Returns a semicolon if this is SCSS, or an empty string if this is Sass.
       #
       # @param fmt [Symbol] `:sass` or `:scss`

data/lib/sass/tree/prop_node.rb

@@ -79,13 +79,17 @@ module Sass::Tree
     protected
 
     def to_src(tabs, opts, fmt)
-      name = self.name.map {|n| n.is_a?(String) ? n : "\#{#{n.to_sass}}"}.join
+      name = self.name.map {|n| n.is_a?(String) ? n : "\#{#{n.to_sass(opts)}}"}.join
+      if name[0] == ?:
+        raise Sass::SyntaxError.new("The \":#{name}: #{self.class.val_to_sass(value, opts)}\" hack is not allowed in the Sass indented syntax")
+      end
+
       old = opts[:old] && fmt == :sass
       initial = old ? ':' : ''
       mid = old ? '' : ':'
-      res = "#{'  ' * tabs}#{initial}#{name}#{mid} #{self.class.val_to_sass(value)}"
+      res = "#{'  ' * tabs}#{initial}#{name}#{mid} #{self.class.val_to_sass(value, opts)}"
       return res + "#{semi fmt}\n" if children.empty?
-      res.rstrip + children_to_src(tabs, opts, fmt)
+      res.rstrip + children_to_src(tabs, opts, fmt).rstrip + semi(fmt) + "\n"
     end
 
     # Computes the CSS for the property.
@@ -175,42 +179,43 @@ module Sass::Tree
 
     class << self
       # @private
-      def val_to_sass(value)
-        return value.to_sass unless value.context == :equals
-        val_to_sass_comma(value).to_sass
+      def val_to_sass(value, opts)
+        return value.to_sass(opts) unless value.context == :equals
+        val_to_sass_comma(value, opts).to_sass(opts)
       end
 
       private
 
-      def val_to_sass_comma(node)
+      def val_to_sass_comma(node, opts)
         return node unless node.is_a?(Sass::Script::Operation)
-        return val_to_sass_concat(node) unless node.operator == :comma
+        return val_to_sass_concat(node, opts) unless node.operator == :comma
 
         Sass::Script::Operation.new(
-          val_to_sass_concat(node.operand1),
-          val_to_sass_comma(node.operand2),
+          val_to_sass_concat(node.operand1, opts),
+          val_to_sass_comma(node.operand2, opts),
           node.operator)
       end
 
-      def val_to_sass_concat(node)
+      def val_to_sass_concat(node, opts)
         return node unless node.is_a?(Sass::Script::Operation)
-        return val_to_sass_div(node) unless node.operator == :concat
+        return val_to_sass_div(node, opts) unless node.operator == :concat
 
         Sass::Script::Operation.new(
-          val_to_sass_div(node.operand1),
-          val_to_sass_concat(node.operand2),
+          val_to_sass_div(node.operand1, opts),
+          val_to_sass_concat(node.operand2, opts),
           node.operator)
       end
 
-      def val_to_sass_div(node)
+      def val_to_sass_div(node, opts)
         unless node.is_a?(Sass::Script::Operation) && node.operator == :div &&
             node.operand1.is_a?(Sass::Script::Number) &&
             node.operand2.is_a?(Sass::Script::Number)
           return node
         end
 
-        Sass::Script::String.new("(#{node.to_sass})")
+        Sass::Script::String.new("(#{node.to_sass(opts)})")
       end
+
     end
   end
 end

data/lib/sass/tree/rule_node.rb

@@ -114,7 +114,7 @@ module Sass::Tree
         if r.is_a?(String)
           r.gsub(/(,[ \t]*)?\n\s*/) {$1 ? $1 + "\n" : " "}
         else
-          "\#{#{r.to_sass}}"
+          "\#{#{r.to_sass(opts)}}"
         end
       end.join
       name = "\\" + name if name[0] == ?:
@@ -122,7 +122,7 @@ module Sass::Tree
     end
 
     def to_scss(tabs, opts = {})
-      name = rule.map {|r| r.is_a?(String) ? r : "\#{#{r.to_sass}}"}.
+      name = rule.map {|r| r.is_a?(String) ? r : "\#{#{r.to_sass(opts)}}"}.
         join.gsub(/^[ \t]*/, '  ' * tabs)
 
       res = name + children_to_src(tabs, opts, :scss)
@@ -316,7 +316,7 @@ module Sass::Tree
       debug_info.map {|k, v| [k.to_s, v.to_s]}.sort.each do |k, v|
         rule = RuleNode.new([""])
         rule.resolved_rules = [[k.to_s.gsub(/[^\w-]/, "\\\\\\0")]]
-        prop = PropNode.new("", "", :new)
+        prop = PropNode.new([""], "", :new)
         prop.resolved_name = "font-family"
         prop.resolved_value = Sass::SCSS::RX.escape_ident(v.to_s)
         rule << prop