haml 3.1.0 → 3.1.1

data/vendor/sass/lib/sass/tree/visitors/to_css.rb

@@ -0,0 +1,216 @@
+# A visitor for converting a Sass tree into CSS.
+class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
+  protected
+
+  def initialize
+    @tabs = 0
+  end
+
+  def visit(node)
+    super
+  rescue Sass::SyntaxError => e
+    e.modify_backtrace(:filename => node.filename, :line => node.line)
+    raise e
+  end
+
+  def with_tabs(tabs)
+    old_tabs, @tabs = @tabs, tabs
+    yield
+  ensure
+    @tabs = old_tabs
+  end
+
+  def visit_root(node)
+    result = String.new
+    node.children.each do |child|
+      next if child.invisible?
+      child_str = visit(child)
+      result << child_str + (node.style == :compressed ? '' : "\n")
+    end
+    result.rstrip!
+    return "" if result.empty?
+    result << "\n"
+    unless Sass::Util.ruby1_8? || result.ascii_only?
+      if node.children.first.is_a?(Sass::Tree::CharsetNode)
+        begin
+          encoding = node.children.first.name
+          # Default to big-endian encoding, because we have to decide somehow
+          encoding << 'BE' if encoding =~ /\Autf-(16|32)\Z/i
+          result = result.encode(Encoding.find(encoding))
+        rescue EncodingError
+        end
+      end
+
+      result = "@charset \"#{result.encoding.name}\";#{
+        node.style == :compressed ? '' : "\n"
+      }".encode(result.encoding) + result
+    end
+    result
+  rescue Sass::SyntaxError => e
+    e.sass_template ||= node.template
+    raise e
+  end
+
+  def visit_charset(node)
+    "@charset \"#{node.name}\";"
+  end 
+
+  def visit_comment(node)
+    return if node.invisible?
+    spaces = ('  ' * [@tabs - node.value[/^ */].size, 0].max)
+
+    content = node.value.gsub(/^/, spaces).gsub(%r{^(\s*)//(.*)$}) do |md|
+      "#{$1}/*#{$2} */"
+    end
+    if content =~ /[^\\]\#\{.*\}/
+      Sass::Util.sass_warn <<MESSAGE
+WARNING:
+On line #{node.line}#{" of '#{node.filename}'" if node.filename}
+Comments will evaluate the contents of interpolations (\#{ ... }) in Sass 3.2.
+Please escape the interpolation by adding a backslash before the hash sign.
+MESSAGE
+    elsif content =~ /\\\#\{.*\}/
+      content.gsub!(/\\(\#\{.*\})/, '\1')
+    end
+    content.gsub!(/\n +(\* *(?!\/))?/, ' ') if (node.style == :compact || node.style == :compressed) && !node.loud
+    content
+  end
+
+  def visit_directive(node)
+    return node.value + ";" unless node.has_children
+    return node.value + " {}" if node.children.empty?
+    result = if node.style == :compressed
+               "#{node.value}{"
+             else
+               "#{'  ' * @tabs}#{node.value} {" + (node.style == :compact ? ' ' : "\n")
+             end
+    was_prop = false
+    first = true
+    node.children.each do |child|
+      next if child.invisible?
+      if node.style == :compact
+        if child.is_a?(Sass::Tree::PropNode)
+          with_tabs(first || was_prop ? 0 : @tabs + 1) {result << visit(child) << ' '}
+        else
+          result[-1] = "\n" if was_prop
+          rendered = with_tabs(@tabs + 1) {visit(child).dup}
+          rendered = rendered.lstrip if first
+          result << rendered.rstrip + "\n"
+        end
+        was_prop = child.is_a?(Sass::Tree::PropNode)
+        first = false
+      elsif node.style == :compressed
+        result << (was_prop ? ";" : "") << with_tabs(0) {visit(child)}
+        was_prop = child.is_a?(Sass::Tree::PropNode)
+      else
+        result << with_tabs(@tabs + 1) {visit(child)} + "\n"
+      end
+    end
+    result.rstrip + if node.style == :compressed
+                      "}"
+                    else
+                      (node.style == :expanded ? "\n" : " ") + "}\n"
+                    end
+  end
+
+  def visit_media(node)
+    str = with_tabs(@tabs + node.tabs) {visit_directive(node)}
+    str.gsub!(/\n\Z/, '') unless node.style == :compressed || node.group_end
+    str
+  end
+
+  def visit_prop(node)
+    tab_str = '  ' * (@tabs + node.tabs)
+    if node.style == :compressed
+      "#{tab_str}#{node.resolved_name}:#{node.resolved_value}#{'!important' if node.important}"
+    else
+      "#{tab_str}#{node.resolved_name}: #{node.resolved_value}#{' !important' if node.important};"
+    end
+  end
+
+  def visit_rule(node)
+    with_tabs(@tabs + node.tabs) do
+      rule_separator = node.style == :compressed ? ',' : ', '
+      line_separator =
+        case node.style
+          when :nested, :expanded; "\n"
+          when :compressed; ""
+          else; " "
+        end
+      rule_indent = '  ' * @tabs
+      per_rule_indent, total_indent = [:nested, :expanded].include?(node.style) ? [rule_indent, ''] : ['', rule_indent]
+
+      joined_rules = node.resolved_rules.members.map do |seq|
+        rule_part = seq.to_a.join
+        rule_part.gsub!(/\s*([^,])\s*\n\s*/m, '\1 ') if node.style == :compressed
+        rule_part
+      end.join(rule_separator)
+
+      joined_rules.sub!(/\A\s*/, per_rule_indent)
+      joined_rules.gsub!(/\s*\n\s*/, "#{line_separator}#{per_rule_indent}")
+      total_rule = total_indent << joined_rules
+
+      to_return = ''
+      old_spaces = '  ' * @tabs
+      spaces = '  ' * (@tabs + 1)
+      if node.style != :compressed
+        if node.options[:debug_info]
+          to_return << visit(debug_info_rule(node.debug_info, node.options)) << "\n"
+        elsif node.options[:line_comments]
+          to_return << "#{old_spaces}/* line #{node.line}"
+
+          if node.filename
+            relative_filename = if node.options[:css_filename]
+              begin
+                Pathname.new(node.filename).relative_path_from(
+                  Pathname.new(File.dirname(node.options[:css_filename]))).to_s
+              rescue ArgumentError
+                nil
+              end
+            end
+            relative_filename ||= node.filename
+            to_return << ", #{relative_filename}"
+          end
+
+          to_return << " */\n"
+        end
+      end
+
+      if node.style == :compact
+        properties = with_tabs(0) {node.children.map {|a| visit(a)}.join(' ')}
+        to_return << "#{total_rule} { #{properties} }#{"\n" if node.group_end}"
+      elsif node.style == :compressed
+        properties = with_tabs(0) {node.children.map {|a| visit(a)}.join(';')}
+        to_return << "#{total_rule}{#{properties}}"
+      else
+        properties = with_tabs(@tabs + 1) {node.children.map {|a| visit(a)}.join("\n")}
+        end_props = (node.style == :expanded ? "\n" + old_spaces : ' ')
+        to_return << "#{total_rule} {\n#{properties}#{end_props}}#{"\n" if node.group_end}"
+      end
+
+      to_return
+    end
+  end
+
+  private
+
+  def debug_info_rule(debug_info, options)
+    node = Sass::Tree::DirectiveNode.new("@media -sass-debug-info")
+    debug_info.map {|k, v| [k.to_s, v.to_s]}.sort.each do |k, v|
+      rule = Sass::Tree::RuleNode.new([""])
+      rule.resolved_rules = Sass::Selector::CommaSequence.new(
+        [Sass::Selector::Sequence.new(
+            [Sass::Selector::SimpleSequence.new(
+                [Sass::Selector::Element.new(k.to_s.gsub(/[^\w-]/, "\\\\\\0"), nil)])
+            ])
+        ])
+      prop = Sass::Tree::PropNode.new([""], "", false, :new)
+      prop.resolved_name = "font-family"
+      prop.resolved_value = Sass::SCSS::RX.escape_ident(v.to_s)
+      rule << prop
+      node << rule
+    end
+    node.options = options.merge(:debug_info => false, :line_comments => false, :style => :compressed)
+    node
+  end
+end

data/vendor/sass/lib/sass/tree/warn_node.rb

@@ -4,39 +4,15 @@ module Sass
     #
     # @see Sass::Tree
     class WarnNode < Node
+      # The expression to print.
+      # @return [Script::Node]
+      attr_reader :expr
+
       # @param expr [Script::Node] The expression to print
       def initialize(expr)
         @expr = expr
         super()
       end
-
-      protected
-
-      # @see Node#to_src
-      def to_src(tabs, opts, fmt)
-        "#{'  ' * tabs}@warn #{@expr.to_sass(opts)}#{semi fmt}\n"
-      end
-
-      # Prints the expression to STDERR with a stylesheet trace.
-      #
-      # @param environment [Sass::Environment] The lexical environment containing
-      #   variable and mixin values
-      def _perform(environment)
-        environment.push_frame(:filename => filename, :line => line)
-        res = @expr.perform(environment)
-        res = res.value if res.is_a?(Sass::Script::String)
-        msg = "WARNING: #{res}\n"
-        environment.stack.reverse.each_with_index do |entry, i|
-          msg << "        #{i == 0 ? "on" : "from"} line #{entry[:line]}" <<
-            " of #{entry[:filename] || "an unknown file"}"
-          msg << ", in `#{entry[:mixin]}'" if entry[:mixin]
-          msg << "\n"
-        end
-        Sass::Util.sass_warn msg
-        []
-      ensure
-        environment.pop_frame
-      end
     end
   end
 end

data/vendor/sass/lib/sass/tree/while_node.rb

@@ -5,44 +5,14 @@ module Sass::Tree
   #
   # @see Sass::Tree
   class WhileNode < Node
-    # @param expr [Script::Node] The parse tree for the continue expression
+    # The parse tree for the continuation expression.
+    # @return [Script::Node]
+    attr_reader :expr
+
+    # @param expr [Script::Node] See \{#expr}
     def initialize(expr)
       @expr = expr
       super()
     end
-
-    protected
-
-    # @see Node#to_src
-    def to_src(tabs, opts, fmt)
-      "#{'  ' * tabs}@while #{@expr.to_sass(opts)}" + children_to_src(tabs, opts, fmt)
-    end
-
-    # Runs the child nodes until the continue expression becomes false.
-    #
-    # @param environment [Sass::Environment] The lexical environment containing
-    #   variable and mixin values
-    # @return [Array<Tree::Node>] The resulting static nodes
-    # @see Sass::Tree
-    def _perform(environment)
-      children = []
-      new_environment = Sass::Environment.new(environment)
-      while @expr.perform(environment).to_bool
-        children += perform_children(new_environment)
-      end
-      children
-    end
-
-    # Returns an error message if the given child node is invalid,
-    # and false otherwise.
-    #
-    # {ExtendNode}s are valid within {WhileNode}s.
-    #
-    # @param child [Tree::Node] A potential child node.
-    # @return [Boolean, String] Whether or not the child node is valid,
-    #   as well as the error message to display if it is invalid
-    def invalid_child?(child)
-      super unless child.is_a?(ExtendNode)
-    end
   end
 end

data/vendor/sass/lib/sass/util.rb

@@ -270,47 +270,6 @@ module Sass
       version_gt(v1, v2) || !version_gt(v2, v1)
     end
 
-    # A wrapper for `Marshal.dump` that calls `#_before_dump` on the object
-    # before dumping it, `#_after_dump` afterwards.
-    # It also calls `#_around_dump` and passes it a block in which the object is dumped.
-    #
-    # If any of these methods are undefined, they are not called.
-    #
-    # This will recursively call itself on members of arrays and hashes,
-    # but not of user-defined objects.
-    # This means that user-defined objects that need their members' `#_before_dump` etc. methods called
-    # must call `Haml::Util.dump` and `Haml::Util.load` manually on those members.
-    #
-    # @param obj [Object] The object to dump.
-    # @return [String] The dumped data.
-    def dump(obj)
-      obj._before_dump if obj.respond_to?(:_before_dump)
-      return convert_and_dump(obj) unless obj.respond_to?(:_around_dump)
-      res = nil
-      obj._around_dump {res = convert_and_dump(obj)}
-      res
-    ensure
-      obj._after_dump if obj.respond_to?(:_after_dump)
-    end
-
-    # A wrapper for `Marshal.load` that calls `#_after_load` on the object
-    # after loading it, if it's defined.
-    #
-    # @param data [String] The data to load.
-    # @return [Object] The loaded object.
-    def load(data)
-      obj = Marshal.load(data)
-
-      if obj.is_a?(Array)
-        obj = obj.map {|e| Sass::Util.load(e)}
-      elsif obj.is_a?(Hash)
-        obj = map_hash(obj) {|k, v| [Sass::Util.load(k), Sass::Util.load(v)]}
-      end
-
-      obj._after_load if obj.respond_to?(:_after_load)
-      obj
-    end
-
     # Throws a NotImplementedError for an abstract method.
     #
     # @param obj [Object] `self`
@@ -706,14 +665,5 @@ MSG
       return lcs_backtrace(c, x, y, i, j-1, &block) if c[i][j-1] > c[i-1][j]
       return lcs_backtrace(c, x, y, i-1, j, &block)
     end
-
-    def convert_and_dump(obj)
-      if obj.is_a?(Array)
-        obj = obj.map {|e| dump(e)}
-      elsif obj.is_a?(Hash)
-        obj = map_hash(obj) {|k, v| [dump(k), dump(v)]}
-      end
-      Marshal.dump(obj)
-    end
   end
 end

data/vendor/sass/sass.gemspec

@@ -22,7 +22,7 @@ SASS_GEMSPEC = Gem::Specification.new do |spec|
   spec.add_development_dependency 'maruku', '>= 0.5.9'
 
   readmes = Dir['*'].reject{ |x| x =~ /(^|[^.a-z])[a-z]+/ || x == "TODO" }
-  spec.executables = ['sass', 'css2sass', 'sass-convert']
+  spec.executables = ['sass', 'sass-convert']
   spec.files = Dir['rails/init.rb', 'lib/**/*', 'vendor/**/*',
     'bin/*', 'test/**/*', 'extra/**/*', 'Rakefile', 'init.rb',
     '.yardopts'] + readmes

data/vendor/sass/test/sass/conversion_test.rb

@@ -165,14 +165,6 @@ SASS
 foo bar {
   baz: 12 $bang "bip"; }
 SCSS
-
-    assert_sass_to_scss <<SCSS, <<SASS
-foo bar {
-  baz: 12 $bang bip; }
-SCSS
-foo bar
-  baz= 12 $bang "bip"
-SASS
   end
 
   def test_dynamic_properties_with_old
@@ -183,14 +175,6 @@ SASS
 foo bar {
   baz: 12 $bang "bip"; }
 SCSS
-
-    assert_sass_to_scss <<SCSS, <<SASS, :old => true
-foo bar {
-  baz: 12 $bang bip; }
-SCSS
-foo bar
-  :baz= 12 $bang "bip"
-SASS
   end
 
   def test_multiline_properties
@@ -842,22 +826,12 @@ SASS
     a: $baz $bang; } }
 SCSS
 
-    assert_scss_to_sass <<SASS, <<SCSS
-=foo-bar($baz, $bang: foo)
-  baz
-    a: $baz $bang
-SASS
-@mixin foo-bar($baz, $bang = "foo") {
-  baz {
-    a: $baz $bang; } }
-SCSS
-
     assert_sass_to_scss <<SCSS, <<SASS
 @mixin foo-bar($baz, $bang: foo) {
   baz {
     a: $baz $bang; } }
 SCSS
-=foo-bar($baz, $bang = "foo")
+=foo-bar($baz, $bang: foo)
   baz
     a: $baz $bang
 SASS
@@ -901,6 +875,42 @@ foo {
 SCSS
   end
 
+  def test_argless_function_definition
+    assert_renders <<SASS, <<SCSS
+@function foo()
+  $var: 1 + 1
+  @return $var
+SASS
+@function foo() {
+  $var: 1 + 1;
+  @return $var; }
+SCSS
+  end
+
+  def test_function_definition_without_defaults
+    assert_renders <<SASS, <<SCSS
+@function foo($var1, $var2)
+  @if $var1
+    @return $var1 + $var2
+SASS
+@function foo($var1, $var2) {
+  @if $var1 {
+    @return $var1 + $var2; } }
+SCSS
+  end
+
+  def test_function_definition_with_defaults
+    assert_renders <<SASS, <<SCSS
+@function foo($var1, $var2: foo)
+  @if $var1
+    @return $var1 + $var2
+SASS
+@function foo($var1, $var2: foo) {
+  @if $var1 {
+    @return $var1 + $var2; } }
+SCSS
+  end
+
   def test_variable_definition
     assert_renders <<SASS, <<SCSS
 $var1: 12px + 15px
@@ -915,8 +925,6 @@ foo {
   $var2: flaz(#abcdef);
   val: $var1 $var2; }
 SCSS
-
-    assert_sass_to_scss '$var: 12px $bar baz;', '$var = 12px $bar "baz"'
   end
 
   def test_guarded_variable_definition
@@ -933,8 +941,6 @@ foo {
   $var2: flaz(#abcdef) !default;
   val: $var1 $var2; }
 SCSS
-
-    assert_sass_to_scss '$var: 12px $bar baz !default;', '$var ||= 12px $bar "baz"'
   end
 
   def test_multiple_variable_definitions
@@ -1078,62 +1084,6 @@ SCSS
     end
   end
 
-  # Sass 3 Deprecation conversions
-
-  def test_simple_quoted_strings_unquoted_with_equals
-    assert_sass_to_scss '$var: 1px foo + bar baz;', '!var = 1px "foo" + "bar" baz'
-    assert_sass_to_scss '$var: -foo-bar;', '!var = "-foo-bar"'
-  end
-
-  def test_complex_quoted_strings_explicitly_unquoted_with_equals
-    assert_sass_to_scss '$var: 1px unquote("foo + bar") baz;', '!var = 1px "foo + bar" baz'
-    assert_sass_to_scss "$var: unquote('foo\"bar');", '!var = "foo\"bar"'
-  end
-
-  def test_division_asserted_with_equals
-    assert_sass_to_scss <<SCSS, <<SASS
-foo {
-  a: (1px / 2px); }
-SCSS
-foo
-  a = 1px / 2px
-SASS
-  end
-
-  def test_division_not_asserted_with_equals_when_unnecessary
-    assert_sass_to_scss <<SCSS, <<SASS
-$var: 1px / 2px;
-
-foo {
-  a: $var; }
-SCSS
-!var = 1px / 2px
-
-foo
-  a = !var
-SASS
-
-    assert_sass_to_scss <<SCSS, <<SASS
-$var: 1px;
-
-foo {
-  a: $var / 2px; }
-SCSS
-!var = 1px
-
-foo
-  a = !var / 2px
-SASS
-
-    assert_sass_to_scss <<SCSS, <<SASS
-foo {
-  a: 1 + 1px / 2px; }
-SCSS
-foo
-  a = 1 + 1px / 2px
-SASS
-  end
-
   def test_nested_properties
     assert_renders <<SASS, <<SCSS
 div
@@ -1181,24 +1131,25 @@ div
 SASS
   end
 
-  def test_sass2_var_in_property_interpolation
-assert_sass_to_scss <<SCSS, <<SASS
-foo {
-  a: b \#{$c} d; }
-SCSS
-foo
-  a: b \#{!c} d
+  def test_loud_comment_conversion
+    assert_renders(<<SASS, <<SCSS)
+/*! \#{"interpolated"}
+/*!
+ *  \#{"also interpolated"}
 SASS
-  end
-
-  def test_sass2_var_in_selector_interpolation
-assert_sass_to_scss <<SCSS, <<SASS
-foo-\#{$c} {
-  a: b; }
+/*! \#{"interpolated"} */
+/*!
+ *  \#{"also interpolated"} */
 SCSS
-foo-\#{!c}
-  a: b
+    assert_renders(<<SASS, <<SCSS)
+//! \#{"interpolated"}
+//!
+//! \#{"also interpolated"}
 SASS
+//! \#{"interpolated"}
+//!
+//! \#{"also interpolated"}
+SCSS
   end
 
   private